Constraint Locality in Learned Syndrome Decoding for 3D Occupancy Grids
A guided tutorial for verifying you understand the paper you wrote.
Companion to Guarraci, Constraint Locality in Learned Syndrome Decoding for 3D Occupancy Grids (Galatheus, May 2026). Every number below is pulled from the paper's tables and the reproducer artifacts in data/clean-v2-may02-rsfix/ and data/clean-v2-may02-strata/.
What this covers
- In one sentence + why it matters
- Background you need (from first principles)
- What the paper actually does
- The results, explained
- How to read it like a skeptical reviewer
- Glossary
- Key takeaways
1. In one sentence
When a strong neural network has already guessed what a 3D shape looks like, forcing that guess to exactly satisfy a set of big, global parity equations makes it worse, but gently nudging it to agree with many small, overlapping local parity checks placed on the object's surface makes it better — and a short theory of "check weight" explains why.
Why it matters
There's a tempting idea in compression and coding: you have a learned model that almost reconstructs the data, and you also have some exact algebraic constraints (parity checks) the true data must satisfy. Surely enforcing the constraints can only help — it pins the answer to the set of valid solutions, right?
This paper shows that intuition is backwards in the regime that actually matters (a good learned proposal that is already 90%+ correct). Hard-enforcing high-weight algebraic constraints throws away most of what the network got right. The fix is not "more constraints" or "better algebra" — it's constraint geometry: checks must be local, overlapping, and aimed at the uncertain parts of the prediction. The paper is careful to frame this as a design principle / diagnosis, not a finished compression codec.
Scope check (the paper says so explicitly)
The abstract and discussion state plainly: this is "the experimental isolation of when algebraic constraints help or hurt learned reconstruction," not "a complete production codec or state-of-the-art compression system." Hold that framing in mind for the whole tutorial — it changes which claims you should scrutinize.
2. Background you need
You do not need a coding-theory background to follow the paper. Below is every prerequisite concept built up from scratch, in roughly the order the paper uses them.
2.1 Bits, vectors, and GF(2) (parity arithmetic)
A binary vector is just a list of 0s and 1s, written $\mathbf{x}\in\{0,1\}^N$. Here each entry is one voxel (a 3D pixel): 1 = "occupied," 0 = "empty." The grid is $32\times32\times32$, so $N = 32^3 = 32{,}768$ voxels.
GF(2) ("Galois Field of 2 elements," also written $\mathbb{F}_2$) is arithmetic where the only numbers are 0 and 1 and addition wraps around: $1+1=0$. This is exactly the logical XOR / "parity" operation. A parity check asks: "of this chosen set of bits, is the number of 1s even or odd?" That single yes/no answer is one parity bit.
Analogy
A parity check is the bouncer counting hands raised in a group. He doesn't learn who raised a hand — only whether the count is even or odd. If you tell him "the true count was even" but he sees odd, he knows someone in the group is wrong, but not which person. That ambiguity is the whole story of this paper.
2.2 Parity-check matrix, syndrome, and the underdetermined problem
Stack $M$ parity checks into a matrix $\mathbf{H}\in\{0,1\}^{M\times N}$. Each row is one check; the 1s in that row mark which voxels it sums. Applying all checks to the data gives the syndrome:
$$\mathbf{s} = \mathbf{H}\mathbf{x} \bmod 2 \;\in\; \{0,1\}^M.$$
The syndrome is a short fingerprint of the data: $M$ parity bits summarizing $N$ voxels.
The decoder's job is the reverse: given $\mathbf{s}$, recover $\mathbf{x}$. Here is the crux. In this paper $M = 2{,}977$ checks but $N = 32{,}768$ voxels — far fewer equations than unknowns. The system is underdetermined. The set of vectors consistent with a given syndrome is called a coset, and its size is astronomically large:
$$2^{\,N - \operatorname{rank}(\mathbf{H})} \;=\; 2^{\,32768 - 2977} \;=\; 2^{\,29791}.$$
Intuition: how big is $2^{29791}$?
For comparison, there are about $2^{266}$ atoms in the observable universe. The syndrome eliminates only $2{,}977$ bits of uncertainty out of $32{,}768$. So the syndrome cannot identify the shape on its own. Whatever recovers the shape, it is mostly not the algebra. This is why the paper keeps insisting "the learned proposal does most of the work."
2.3 Where the extra information comes from: side information and a learned proposal
Since the syndrome alone is hopeless, the decoder needs extra information to pick one member of the gigantic coset. The paper supplies two things:
- Spectral side-information $\mathbf{c}$: a handful of low-frequency transform coefficients (think of a blurry, low-resolution sketch of the shape — like the first few terms of a JPEG-style frequency decomposition). Sending these is cheap and gives a rough sense of where the object is.
- A learned spatial proposal: a neural network, trained on lots of real 3D objects (ShapeNet), that looks at the blurry sketch plus syndrome-derived features and outputs a confident guess for every voxel: $P_\theta(x_i=1\mid \mathbf{c},\mathbf{s})$.
This is the part that makes the problem learnable. The network has seen thousands of chairs, tables, and lamps, so given a blurry sketch it knows what a plausible sharp shape looks like. Its raw proposal is already very good (we will see IoU $\approx 0.94$). The research question is what to do after that.
Analogy
This is the "decoder side information" setting of Slepian–Wolf / Wyner–Ziv source coding (cited in the paper): the encoder can send a tiny fingerprint because the decoder already has a strong correlated guess. Like texting a friend "meet at the usual place" — the message is short only because the friend already shares the context.
2.4 IoU: how "right" a reconstruction is
Intersection over Union (IoU) measures overlap between the predicted occupied voxels and the true occupied voxels:
$$\mathrm{IoU} = \frac{|\text{predicted-on} \cap \text{true-on}|}{|\text{predicted-on} \cup \text{true-on}|}.$$
IoU = 1.0 is perfect; 0 means no overlap at all. Crucially, IoU ignores the empty background: it only counts occupied voxels. That matters because these grids are mostly empty (mean fill rate ~8%), so a metric like raw voxel accuracy would be flattered by getting the easy zeros right. The paper uses IoU precisely so that improvements reflect getting the actual shape surface right.
2.5 Belief propagation (BP) and the Tanner graph
Instead of hard enforcing checks, you can do a soft, iterative negotiation. Picture a Tanner graph: two columns of nodes. On one side, variable nodes (one per voxel), each holding a "belief" — a soft probability of being on or off, initialized from the network's confidence. On the other side, check nodes (one per parity equation), each holding the known syndrome value (even/odd).
An edge connects a check to each voxel it sums. Belief propagation passes messages back and forth: each check tells its voxels "given everyone else and my required parity, here's what I think you should be," and each voxel combines incoming opinions with its own network confidence. After a few rounds (the code uses ~30 iterations with damping) the beliefs settle. Voxels the network was confident about barely move; uncertain voxels get pulled toward whatever makes the local checks consistent.
Analogy
BP is a group of neighbors comparing notes. Each parity check is a small committee that knows only its own headcount-parity. If most members of a committee are confident, the committee can usually deduce the one uncertain member. If everyone in a committee is uncertain, the committee is stuck. That is exactly why small, overlapping committees work and one giant committee (a high-weight global check) does not.
2.6 Check weight, and the three decoding operations
The weight $w$ of a check is how many voxels it sums (the number of 1s in that row of $\mathbf{H}$). A weight-2 check sums two voxels; a weight-1024 "global" check sums a thousand. Weight is the single most important quantity in this paper.
The paper contrasts three ways to combine the learned proposal with the syndrome:
- (A) Hard algebraic projection. Take the network's guess $\tilde{\mathbf{x}}$, find where it violates the syndrome (residual $\mathbf{r}=\mathbf{s}-\mathbf{H}\tilde{\mathbf{x}}$ over GF(2)), and apply the smallest algebraic correction $\hat{\mathbf{x}}=\tilde{\mathbf{x}}+\mathbf{L}\mathbf{r}$ (with $\mathbf{H}\mathbf{L}=\mathbf{I}$) that makes the syndrome exactly satisfied. "Smallest" here means minimum-Hamming-weight (fewest bits flipped) — chosen by algebraic convenience, not by what looks like a real shape.
- (B) Learned proposal only. Just trust the network; don't touch the syndrome at inference. Output may slightly violate the syndrome.
- (C) Proposal + local BP refinement. Use the network's soft output as the variable beliefs, then run BP on a Tanner graph of well-chosen local checks to nudge it.
The paper's one-line summary: (A) hurts, (B) is strong, and (C) beats (B) only when the checks have the right (local, overlapping, surface-targeted) structure.
3. What the paper actually does
3.1 The setup
The data is $32^3$ binary occupancy grids of ShapeNet objects. A flat 3D residual network (ResNet-style, width 192, depth 12, ~25M params, no downsampling) takes a canonical base solution + the low-frequency spectral field + a coarse occupancy map, conditioned on the syndrome, and predicts a per-voxel occupancy logit. All headline numbers are averaged over three training seeds (42/43/44), evaluated on 200 ShapeNet validation samples, reported as mean ± SEM.
A detail worth noticing
The paper reports that a tiny width-48, depth-8 model (~1.68M params) reaches comparable IoU to the 25M-param model at $32^3$. The conclusion drawn: the proposal network is heavily over-parameterized at this resolution, so model capacity is not the bottleneck — constraint design is. This is offered only as a qualitative observation; the multi-seed tables all use the width-192 model.
3.2 The diagnosis experiment (does hard projection help?)
Run the network (operation B), measure its IoU, then apply hard projection (operation A) and re-measure. Also track: how many checks were violated before projection, how many bits the projection flipped, and — the key diagnostic — what fraction of those flips moved toward the ground truth ("helpful flips").
3.3 The constraint-locality experiment (which checks help?)
Hold the learned proposal fixed and swap the post-processing. Compare hard projection (global, high-weight checks) against BP refinement using three families of local surface checks of decreasing weight: $2^3$ patches (weight 8), gradient runs (weight 4), and neighbor pairs (weight 2). All three local families are overlapping (adjacent checks share voxels) and surface-targeted (placed where the proposal is uncertain, at object boundaries).
3.4 The content-adaptive trick
Where do you put the surface checks? You could signal their locations, but that costs bits. The paper's trick: both encoder and decoder run the same surface detection on the same shared spectral side-information. They independently arrive at the same surface voxels, so the check locations require zero extra signaling bits. (The check values — the local syndrome — still cost bits, which is why those bits are reported as a separate diagnostic column, not folded into the rate–distortion curve.)
3.5 The theory (why weight controls usefulness)
Suppose each voxel in the proposal is independently correct with probability $p\in(\tfrac12,1)$. For a single weight-$w$ check, the probability it contains exactly one error is
$$P_1(w,p) = w\,(1-p)\,p^{\,w-1}.$$
This is the single-error-informative regime: if a check has exactly one wrong voxel inside it, and you can identify which voxel (via the prior or overlapping checks), the syndrome tells you exactly how to fix it. The function $P_1$ is maximized at
$$w^* = -\frac{1}{\ln p},$$
and decays exponentially for $w \gg w^*$. Worked example from the paper (for $p=0.88$): $w^*\approx 8$, $P_1(4)=0.33$, but $P_1(64)=5\times10^{-4}$. With 32 checks, weight-4 local checks give ~10.6 single-error-informative checks; weight-64 global checks give ~0.016 — essentially none.
Why the optimum is small
There's a tension. A bigger check covers more voxels, so it's more likely to catch at least one error — but it's also more likely to catch two or more, and with multiple errors the parity bit can't tell you which voxels are wrong (two flips can cancel, leaving the parity looking fine). The sweet spot $w^* = -1/\ln p$ balances "big enough to usually contain an error" against "small enough that it's usually just one." For high-accuracy proposals ($p$ near 1), $w^*$ is small — exactly the local-check regime.
The second theorem makes the negative case precise. If your correction policy is allowed to use only the residual (i.e., "a check is violated, flip something in it") with no external prior, then for any weight $w\ge 3$ and $p>\tfrac12$ the expected number of errors goes up, not down:
$$\mathbb{E}[\Delta\mathrm{err}\mid r\neq 0] = \frac{1}{Z}\sum_{\substack{k=1\\k\text{ odd}}}^{w}\binom{w}{k}(1-p)^k p^{\,w-k}\,\frac{w-2k}{w},$$
which is strictly positive for $w\ge3$, with leading order $(w-2)/w$ as $p\to1$. The intuition: a violated weight-$w$ check almost always has exactly one error (mass concentrates at $k=1$ when $p$ is high), and a blind flip lands on the one wrong voxel only $1/w$ of the time — so $w-1$ times out of $w$ you break a correct voxel. Corollary (a prior is necessary): no residual-only policy can do better than this, because the residual is blind to which voxel is wrong. You need an external information source — the learned proposal, or overlapping local checks — to break the tie.
Honesty note the paper makes itself
The paper explicitly says Theorem 2 replaces an earlier, false deterministic claim that "every multi-error correction is harmful." That's false because two errors inside a check can cancel, so a flip can occasionally reduce the count. The corrected, probabilistic statement is about expectation, and only that weaker claim is defended. This is exactly the kind of self-correction a careful reviewer wants to see survive in the final draft.
4. The results, explained
4.1 The main finding: hard projection backfires
Table 1 (paper): Clean hard algebraic projection diagnosis. 200 ShapeNet validation samples, spectral level 4, mean ± SEM over seeds 42/43/44.
| Metric | Value |
|---|
| Constraint violations before projection | 47.6 ± 4.5 / 2,977 (1.6%) |
| Bits flipped by projection | 52.5 ± 5.2 / 32,768 (0.16%) |
| IoU before projection | 0.9370 ± 0.0028 |
| IoU after projection | 0.8782 ± 0.0085 (−0.0588 ± 0.0058) |
| Mean |logit| of flipped bits | 8.665 ± 0.020 |
| Mean |logit| of kept bits | 14.151 ± 0.016 |
| Fraction of helpful flips | 5.3% ± 0.5% |
How to read this. The proposal already satisfies 98.4% of the checks; only 47.6 of 2,977 are violated. Projection flips a tiny number of bits (52.5, or 0.16% of the grid) to fix those violations. Yet IoU drops by about 0.059 — and the smoking gun is the last row: only 5.3% of the flips moved toward the truth, so 94.7% moved away. The projection also tends to flip lower-confidence bits (|logit| 8.7 vs 14.2 for kept bits), which sounds reasonable — but it's still wrong 95% of the time, because algebraic minimality has nothing to do with where the real shape is.
Why it happens (and why it's not surprising once you see it): the global checks operate at the scale of full rows (32 voxels), while real reconstruction errors live on object surfaces (2–8 voxels). The right-inverse finds the minimum-Hamming-weight way to satisfy the syndrome — a quantity with no relationship to spatial coherence. This is a concrete instance of Theorem 2's "residual-only correction increases expected error."
4.2 The flip: local overlapping checks help
Table 2 (paper): Same learned proposal (IoU 0.9370 ± 0.0028), different post-processing. 200 samples, level 4, seeds 42/43/44. "Extra bits" are local syndrome values beyond the fixed payload — a constraint-design ablation, not a rate-matched codec comparison.
| Post-processing | Weight | Overlap | Extra bits | ΔIoU |
|---|
| None (proposal only) | — | — | 0 | baseline (0.9370) |
| Hard projection (global) | 32–1024 | low | 0 | −0.0588 ± 0.0058 |
| Surface patches ($2^3$) | 8 | yes | 4,205 | +0.0363 ± 0.0026 |
| Surface gradient runs | 4 | yes | 12,682 | +0.0603 ± 0.0031 |
| Surface neighbor pairs | 2 | yes | 12,806 | +0.0623 ± 0.0028 |
The contrast is the whole paper. Same proposal, same data. Global high-weight projection: −0.059. Local low-weight overlapping BP: +0.036 to +0.062. And there's a clean monotone trend — lower weight helps more (weight 2 > weight 4 > weight 8), exactly as the $P_1(w,p)$ theory predicts, since smaller checks live closer to the single-error-informative sweet spot for a high-accuracy proposal.
Read the "Extra bits" column carefully
The lower-weight winners also cost more extra syndrome bits (12,800 for weight-2 vs 4,205 for weight-8 patches). So weight-2 is not a free lunch — it buys its bigger ΔIoU with ~3× the side-information. This is why the paper labels these "extra diagnostic bits," keeps them out of the rate–distortion curve, and frames the table as a constraint-design ablation, not a rate-matched codec comparison. A reviewer should not read "+0.062" as "free improvement."
4.3 The rate–distortion diagnostic (more sketch ⇒ better reconstruction)
Table 3 (paper): Nominal rate–distortion on 200 validation samples, seeds 42/43/44. Bits = 2,977 syndrome + 8 coarse + 8 per retained low-frequency spectral coefficient. Post-hard-projection IoU, before surface-BP. No entropy-coded bitstream is implemented.
| Spectral level | Bits | Mean IoU |
|---|
| L2 | 3,201 | 0.6947 ± 0.0072 |
| L3 | 3,985 | 0.7941 ± 0.0081 |
| L4 | 5,729 | 0.8781 ± 0.0085 |
| L5 | 8,817 | 0.9380 ± 0.0072 |
| L6 | 13,633 | 0.9729 ± 0.0036 |
| L7 | 20,561 | 0.9908 ± 0.0017 |
| L8 | 29,985 | 0.9970 ± 0.0006 |
This is the expected, "sanity-check" curve: give the proposal more of the low-frequency sketch and reconstruction improves smoothly from IoU 0.69 to 0.997. The L4 row (0.8781) is the post-projection number that matches Table 1's "after projection" entry — the same setting. The paper is upfront that this is a nominal bandwidth diagnostic with an 8-bit-per-coefficient accounting model, not a serialized/quantized/entropy-coded codec. Don't read it as a competitive compression result.
Watch the two different L4 IoUs
You will see both 0.9370 and 0.8781 attached to "L4." They are not a contradiction: 0.9370 is the raw learned proposal (operation B, the baseline in Table 2), and 0.8781 is that same proposal after hard projection (the damaged version, Table 3 and the "after" row of Table 1). Tracking which one a sentence refers to is the single easiest way to misread the paper — and a good self-test that you understand it.
4.4 Density stratification (the effect isn't a background artifact)
Table 4 (paper): Level-4 results split by occupancy rank quartile. 50 validation objects per stratum per seed; mean ± SEM over seeds 42/43/44.
| Stratum | Occupancy | Raw IoU | Hard Δ | Patch Δ | Neighbor Δ |
|---|
| Q1 | 0.62–1.68% | 0.946 ± 0.003 | −0.059 | +0.035 | +0.053 |
| Q2 | 1.68–1.92% | 0.947 ± 0.003 | −0.053 | +0.034 | +0.052 |
| Q3 | 1.93–2.27% | 0.944 ± 0.003 | −0.058 | +0.035 | +0.056 |
| Q4 | 2.28–5.12% | 0.911 ± 0.002 | −0.065 | +0.041 | +0.088 |
Because the validation set is occupancy-sparse, a skeptic might worry the IoU gains are some background-counting artifact. This table answers that: it splits objects into equal-sized density quartiles, and since IoU already ignores true negatives, these are overlap-on-structure numbers. Two things hold across every quartile: hard projection hurts everywhere, and local BP helps everywhere. And the densest, hardest objects (Q4) get the biggest local-BP gain (neighbor Δ = +0.088). The paper's explanation: denser objects expose more surface, which places more local checks where the proposal is uncertain — more single-error-informative checks ⇒ more gain. Hard projection can't capture this because its high-weight checks have negligible $P_1$ in any stratum.
4.5 The auxiliary temporal diagnostic (appendix)
Appendix table (paper): Temporal accumulation on a 20-frame morphing scene, 8% surface tampering per frame. No neural decoder — spectral prior + surface BP only. Deterministic; identical across seeds.
| Decoding strategy | Mean IoU | After 5 frames |
|---|
| Single-frame surface BP | 0.847 | 0.847 |
| + Bayesian accumulation | 0.958 | 0.975 |
This is explicitly a side dish, not part of the central static-grid claim. If several noisy frames of the same scene are available, a per-voxel Bayesian log-odds accumulator (EMA coefficient $\alpha=0.7$, clamped to $\pm5$ to prevent lock-in, soft-decayed on changed voxels) fuses them and lifts IoU from 0.847 to 0.958. Useful to know it composes over time, but the paper does not lean on it.
5. How to read it like a skeptical reviewer
5.1 The central claims to scrutinize
- "Hard projection damages a good proposal." Defended by Table 1's −0.059 ΔIoU and the 94.7%-harmful-flips diagnostic, over 3 seeds with SEMs. The diagnostic is what sells it: it's not just that IoU dropped, it's why (the flips go the wrong way). This is the strongest, most clearly supported claim.
- "Local overlapping surface checks help." Defended by Table 2 (+0.036 to +0.062) and the monotone weight trend, replicated across all four density quartiles in Table 4. Also well supported.
- "Check weight controls local informativeness." This is the theory linking the two. $P_1(w,p)=w(1-p)p^{w-1}$ is elementary and correct; the $w^*=-1/\ln p$ optimum is a one-line calculus result. Treat it as an explanatory model, not a tight bound on IoU — the paper itself frames reconstruction quality as scaling with the number of locally informative checks, not directly with $P_1$.
5.2 Baselines and what's compared to what
The comparison you must keep honest
Table 2 is the load-bearing comparison, and the paper is careful that it holds the proposal fixed — so the only thing varying is the post-processing, which is exactly the right ablation. But the local-check rows spend extra bits the global row does not. The fair reading is: "given a fixed strong proposal, local overlapping checks are the right shape of constraint, and hard global projection is the wrong shape." It is not: "local BP gives free IoU" or "this beats codec X at bitrate Y." The paper does not claim the latter and a reviewer should resist importing it.
Note what is absent from the headline tables: no head-to-head against established voxel/point-cloud codecs (Draco etc. appear only as historical baselines in REPRODUCIBILITY.md, not in the submission tables), and no entropy-coded bitstream. The paper lists exactly this as future work. So "is this competitive compression?" is not a question this paper tries to answer — and you shouldn't grade it as if it did.
5.3 What would falsify the core claim
- If, on a fresh dataset / resolution, hard projection of a strong proposal improved IoU, or the helpful-flip fraction were near 50% rather than ~5%, the "global projection damages" claim would be in trouble.
- If local overlapping surface BP did not beat the raw proposal — or if the weight ordering (2 > 4 > 8) reversed — the locality principle would be undermined.
- If the gains vanished once you matched the extra bit budget against an equally-funded global scheme, the "locality, not bits" interpretation would weaken. (The paper doesn't run this rate-matched comparison; it's the most natural follow-up a reviewer would request.)
5.4 Limitations the paper states itself
- Tested at $32^3$ resolution only.
- Not a complete entropy-coded production codec; rate accounting is nominal (8 bits/coefficient), with no serialized/quantized coefficient bitstream.
- Full rate claims would need to count all payloads: fixed syndrome, surface-refinement syndromes, coarse occupancy, spectral coefficients, and any variable-rate metadata.
- No head-to-head against established codecs (Draco) — future work.
- The surface-attention decoder is reported as a documented negative result (not competitive with the matched-parameter ResNet at $32^3$); included for completeness in the reproducibility audit.
Reviewer's bottom line
The paper is internally consistent, multi-seeded (42/43/44), reports SEMs, traces every number to a single reproducer (reproduce_results.py + the data/clean-v2-* artifacts), and — notably — flags and corrects its own earlier false theorem. The claims are appropriately scoped to "constraint-design diagnosis," and the evidence supports that scope. The honest gaps (rate-matched comparison, larger N, real codec baselines, entropy coding) are named as future work rather than papered over.
6. Glossary
- Occupancy grid / voxel
- A 3D array of 0/1 cells; 1 = occupied. Here $32^3 = 32{,}768$ voxels, $N$ in the equations. A voxel is the 3D analog of a pixel.
- GF(2) / parity
- Arithmetic on $\{0,1\}$ where $1+1=0$ (XOR). A parity check reports whether a chosen set of bits sums to even (0) or odd (1).
- Parity-check matrix $\mathbf{H}$
- $M\times N$ binary matrix; each row is one parity check, with 1s marking the voxels it sums. Here $M=2{,}977$, $N=32{,}768$.
- Syndrome $\mathbf{s}$
- $\mathbf{s}=\mathbf{H}\mathbf{x}\bmod 2$, the $M$-bit fingerprint of the data. Decoding = recovering $\mathbf{x}$ from $\mathbf{s}$ (plus side info).
- Underdetermined / coset
- $M
- Check weight $w$
- Number of voxels a check sums (1s in its row). "Local"/"low-weight" = small $w$ (2–8); "global"/"high-weight" = large $w$ (32–1024).
- Side information $\mathbf{c}$
- Extra data the decoder gets — here low-frequency spectral (transform) coefficients: a cheap blurry sketch of the shape, shared by encoder and decoder.
- Learned proposal $P_\theta$
- A neural network (here a ~25M-param flat 3D ResNet) trained on real 3D objects that outputs a soft per-voxel occupancy guess from side info + syndrome features.
- IoU (Intersection over Union)
- Overlap of predicted-on and true-on voxels divided by their union. Ignores empty background, so it scores the actual shape surface. 1.0 = perfect.
- Hard algebraic projection (operation A)
- Force the proposal to exactly satisfy the syndrome via the minimum-Hamming-weight right-inverse correction $\hat{\mathbf{x}}=\tilde{\mathbf{x}}+\mathbf{L}\mathbf{r}$. The paper shows this damages a good proposal.
- Belief propagation (BP) / Tanner graph
- Iterative soft message-passing between variable nodes (voxels, beliefs from the network) and check nodes (syndrome values) over a bipartite graph. Settles uncertain voxels toward locally consistent values without hard-forcing them.
- Single-error informativeness $P_1(w,p)$
- Probability a weight-$w$ check contains exactly one error: $w(1-p)p^{w-1}$. Maximized at $w^*=-1/\ln p$; decays exponentially for large $w$. The theoretical reason low-weight checks are useful and high-weight ones aren't.
- SEM (standard error of the mean)
- The ± spread reported in the tables, computed across the three seeds (42/43/44). Smaller = more stable across seeds.
- Spectral level (L2–L8)
- How many low-frequency coefficients are retained — i.e., how detailed the shared sketch is. Higher level = more bits, better reconstruction.
7. Key takeaways
- The proposal does the work; constraints only refine. The learned network reaches IoU 0.9370 on its own; post-processing moves it by at most ~0.06. Strong proposals are the prerequisite — constraints are a targeted polish, not the engine.
- Hard projection of a good proposal is actively harmful. −0.059 IoU, with 94.7% of flips moving away from truth, because minimum-Hamming-weight algebra ≠ spatial coherence and global checks act at the wrong (32-voxel) scale.
- Local + overlapping + surface-targeted checks help, and lower weight helps more. +0.036 (w=8) → +0.062 (w=2), replicated across all four density quartiles, with the biggest gains on the densest objects.
- One small theory explains both directions. $P_1(w,p)=w(1-p)p^{w-1}$ peaks at small $w^*=-1/\ln p$ for high-accuracy proposals; residual-only correction provably increases expected error for $w\ge3$, so an external prior (the proposal, or overlapping local checks) is necessary.
- Constraint locations can be free. Deriving surface checks from shared side-information costs zero signaling bits for the locations (the check values still cost bits — reported as a separate diagnostic, not folded into rate–distortion).
- Scope honesty is a feature, not a hedge. This is a constraint-design diagnosis at $32^3$, not a finished codec; it names its gaps (larger N, entropy coding, rate-matched and codec baselines) and even retracts its own earlier over-strong theorem.