Two-chart refinement cell
Implementation & benchmark of arXiv:2608.02624 — Neural network realization of binary refinement iterates via a two-chart atlas selector
Source paper: Neural network realization of binary refinement iterates via a two-chart atlas selector arXiv:2608.02624 ⓘ · analyzed Aug 31, 2026
AI-generated research hypothesis, automatically tested. Not peer-reviewed.
Idea description
Build a recurrent ReLU module that evaluates a binary refinement cascade using a fixed-dimensional state and shared cell weights. Replace hard binary digit selection with two overlapping circle coordinates; switch between their affine state updates only at points where the two candidate updates agree, so the switch is an exact continuous piecewise-linear ReLU operation rather than a multiplicative gate.
Formulas
Mathematical statement
The paper starts from the binary refinement operator $(Vf)(t)=\sum_{j\in\mathbb Z}c_j f(2t-j)$, where $f:\mathbb R\to\mathbb R$ is a seed function and $(c_j)$ is a finitely supported mask. The residual coordinate is represented on the circle $\mathbb T=\mathbb R/\mathbb Z$ in two charts, for example $u=t\bmod 1$ and $v=(t-\tfrac12)\bmod 1$; their coordinate discontinuities occur at different locations. Let $p(x)=a_p x+b_p$ and $q(x)=a_qx+b_q$ be two affine candidate updates that agree at the chart-switch point $x_0$, so $p(x_0)=q(x_0)$. Then $q(x)-p(x)=(a_q-a_p)(x-x_0)$ and the continuous switch can be implemented exactly as $S(x)=p(x)+(a_q-a_p)\operatorname{ReLU}(x-x_0)$ on the side where $q$ is active, with the analogous reflected expression for the opposite side. Applying this componentwise to a finite-dimensional cascade state avoids the invalid operation $s(x)z$ with a discontinuous selector $s$. The refinement recurrence is $V^{n+1}f(t)=\sum_j c_j(V^nf)(2t-j)$, with only finitely many nonzero terms because the mask is finitely supported.
Implementation notes
(1) Integrate this as a small recurrent block for a one-dimensional signal or coordinate-based MLP. The input is a scalar coordinate $t$ and an optional feature vector. Choose a finitely supported mask $c_j$ with indices $j_{\min},\ldots,j_{\max}$, and maintain a state vector $z_k$ containing the current residual coordinate and the finite cascade values needed by the refinement update. Reuse the same cell parameters at every refinement step, so depth is $n$ while parameter count remains constant. At each cell, construct two affine chart representations of the residual coordinate, one centered at $0$ and one centered at $1/2$.
(2) Pseudocode: z = encode_seed_state(t); for k in 1..n: p = affine_update_chart_u(z, c); q = affine_update_chart_v(z, c); z = continuous_switch(p, q, x0); t = 2*t - j; y = sum_j c[j] * cascade_value(z, j); where the finite sum runs over the mask support. For each state coordinate, if branches switch at $x_0$ and satisfy $p(x_0)=q(x_0)$, use p + (slope_q-slope_p)*relu(x-x0) on the appropriate side, or the reflected ReLU for the opposite side. Never multiply the state by a hard binary chart selector.
(3) The paper supplies the exact refinement identity and the continuous chart-switch construction. Estimate or choose empirically the mask, switch locations, and state width. Validate the implementation against a dense-grid reference that directly evaluates the finite refinement sums; record maximum absolute error after every refinement step and use double precision initially.
(4) First experiment: create compactly supported continuous piecewise-linear regression targets with 8--32 breakpoints and compare a standard ReLU MLP against the shared refinement cell for $n=4,8,16$, matched by parameter count and measured FLOPs. Evaluate interpolation error, sampled number of linear regions, training loss at equal compute, and inference latency. Success means lower error or faster loss descent at equal parameter budget, machine-precision agreement with the reference cascade when initialized from the exact mask, and stable error as $n$ grows.
Verification
This idea has not been verified yet.
Verification happens in two stages: Stage 1 — a mechanism check on a toy system confirms the claimed mathematical phenomenon reproduces; Stage 2 — a benchmark implements the idea on a real (small) neural network task and compares it against a tuned baseline over 8 paired seeds with a permutation test.
Artifacts
Artifacts unavailable.