{
 "artifacts": null,
 "category": "architecture",
 "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_latex": [
  "$$(Vf)(t)=\\sum_{j\\in\\mathbb{Z}}c_j f(2t-j),$$",
  "$$u=t\\bmod 1,\\qquad v=(t-\\tfrac12)\\bmod 1,$$",
  "$$p(x_0)=q(x_0)\\;\\Longrightarrow\\;q(x)-p(x)=(a_q-a_p)(x-x_0),$$",
  "$$S(x)=p(x)+(a_q-a_p)\\operatorname{ReLU}(x-x_0),\\qquad \\operatorname{ReLU}(z)=\\max(0,z).$$"
 ],
 "id": 1718,
 "implementation": "(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$.\\n\\n(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.\\n\\n(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.\\n\\n(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.",
 "math_summary": "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.",
 "math_tags": [
  "approximation-theory",
  "dynamical-systems",
  "geometry",
  "linear-algebra"
 ],
 "ml_areas": [
  "mlp",
  "cnn",
  "initialization",
  "inference-speedup"
 ],
 "paper": {
  "arxiv_id": "2608.02624",
  "arxiv_url": "https://arxiv.org/abs/2608.02624",
  "summary_what_math_gives_to_ml": "The paper supplies an exact, fixed-width ReLU realization of binary refinement cascades whose apparent digit-selection discontinuities are removed by a two-chart atlas on the circle. The transferable asset is not refinement itself, but a general construction for implementing piecewise-affine state machines with discrete regime changes without multiplying a continuously varying state by a hard selector. This suggests a weight-shared multiscale neural module: repeated refinement cells can represent exponentially many linear regions with depth linear in the number of refinement steps, while retaining exact continuity and a small state dimension. The most credible first use is as a parameter-efficient CPWL or implicit-signal backbone, initialized from a refinement mask and then optionally fine-tuned.",
  "title": "Neural network realization of binary refinement iterates via a two-chart atlas selector",
  "year": "2026"
 },
 "ratings": {
  "difficulty": 6,
  "novelty": 7,
  "usefulness": 6
 },
 "solves": [
  "scalability",
  "accuracy",
  "inference-speedup"
 ],
 "title": "Two-chart refinement cell",
 "url": "https://synthcore.org/idea/1718/two-chart-refinement-cell",
 "verification": {
  "peer_reviewed": false,
  "status": "unverified",
  "status_label": "Unverified",
  "verdict_source": "deterministic test code (paired-seed permutation statistics)",
  "verification_axes": {
   "benchmark_mechanism": {
    "confirmed": null,
    "tested": false
   },
   "practical_benchmark": {
    "beats_baseline": null,
    "tested": false
   },
   "toy_mechanism_gate": {
    "confirmed": null,
    "tested": false
   }
  }
 }
}