✗ Failed on benchmark 2026

RG Pyramid Flow Matching

Implementation & benchmark of arXiv:2608.23696 — Renormalization Group Flow Matching for Scalable Local Generative Modeling

Usefulness8/10

Difficulty6/10

Novelty6/10

Architecture Speedup Memory Accuracy Diffusion Diffusion sampling Cnn Memory Dynamical systems Pde Probability Functional analysis

Source paper: Renormalization Group Flow Matching for Scalable Local Generative Modeling arXiv:2608.23696 ⓘ · analyzed Sep 1, 2026

AI-generated research hypothesis, automatically tested. Not peer-reviewed.

Idea description

Replace a full-resolution global flow-matching or diffusion model with a hierarchy of local velocity fields operating on progressively finer grids. Coarse levels generate long-wavelength structure and pass it to fine levels through upsampling and residual conditioning, while every velocity network uses only a locality radius prescribed by the RG bound. This should preserve long-range correlations without quadratic global attention or a full-resolution global receptive field.

Formulas

$$R(\Lambda,L,\varepsilon)=O\!\left(\Lambda^{-1}\left[\ln L+\ln(1/\varepsilon)\right]\right),$$

$$\ell_{\mathrm{loc}}(t)\propto \Lambda(t)^{-1},$$

$$\frac{d z_t}{dt}=v_t(z_t),\qquad v_t(z_t)\approx v_{\theta,s}\!\left(\operatorname{patch}_{r_s}(z_t^{(s)}),\,\operatorname{up}(z_t^{(s+1)}),\,t\right),$$

$$\mathcal{L}_{s}(\theta_s)=\mathbb{E}_{x_0,x_1,t}\left\|v_{\theta,s}(z_{s,t},t)-\frac{x_{1}^{(s)}-x_{0}^{(s)}}{1-t}\right\|_2^2,\qquad z_{s,t}=(1-t)x_{0}^{(s)}+t x_{1}^{(s)}.$$

Mathematical statement

The paper's main locality result states that, along the RGFM probability path without lattice rescaling, the locality length needed to approximate the exact probability-flow velocity scales linearly with the running RG length scale: $\ell_{\mathrm{loc}}(t)\propto \Lambda(t)^{-1}$. More specifically, the required radius for error tolerance $\varepsilon$ on a system of linear size $L$ is $R(\Lambda,L,\varepsilon)=O\!\left(\Lambda^{-1}[\ln L+\ln(1/\varepsilon)]\right)$, where $\Lambda$ is the current RG wavenumber cutoff, $L$ is the spatial system size, and $\varepsilon$ is the tolerated local-flow approximation error. The paper proposes representing remaining modes on successively coarser lattices so that the physical locality radius remains $O(L^0)$, meaning constant in lattice units after rescaling. Use a continuous flow $dz_t/dt=v_t(z_t)$, where $z_t$ is the multiscale state and $v_t$ is approximated by a local neural field. At level $s$, let grid spacing be $a_s=2^s$, cutoff be $\Lambda_s\approx \pi/a_s$, and choose a physical patch radius $R_s=\left\lceil c[\ln L+\ln(1/\varepsilon)]/\Lambda_s\right\rceil$. In grid-cell coordinates the radius is $r_s=\lceil R_s/a_s\rceil$, which is approximately constant across levels when $\Lambda_s\propto a_s^{-1}$.

Implementation notes

(1) Integration point: implement this as a replacement for a full-resolution flow-matching or diffusion U-Net. Construct a dyadic pyramid $x^{(S)},x^{(S-1)},\ldots,x^{(0)}$, where $x^{(S)}$ is the coarsest grid and $x^{(0)}$ is the target resolution. At each level use a convolutional or windowed-attention velocity network $v_{\theta,s}$, conditioned on the level index, continuous time $t$, and an upsampled state or feature map from level $s+1$. Avoid global attention. (2) Pseudocode: sample Gaussian noise $x_0^{(S)}$; integrate the coarse ODE from $t=0$ to 1 using $v_{\theta,S}$; upsample the result to initialize level $S-1$, add independent fine-scale noise, and integrate $v_{\theta,S-1}$; repeat down to level 0. During training, construct data and noise pyramids, sample $t\sim U[0,1]$, form $z_{s,t}=(1-t)x_0^{(s)}+tx_1^{(s)}$, and regress the velocity target shown in $\mathcal{L}_s$. Restrict each output location to a patch of radius $r_s=\lceil c[\ln L+\ln(1/\varepsilon)]/(\Lambda_s a_s)\rceil$. (3) Compute from the paper's mathematics: the level-dependent receptive-field radius and the coarse-to-fine schedule. Estimate the unknown constant $c$ by sweeping candidate radii and selecting the smallest radius whose validation correlation error is below $\varepsilon$. The cutoff approximation $\Lambda_s=\pi/a_s$, pyramid filters, and upsampling rule are engineering choices. (4) First experiment: train on CIFAR-10 at 32x32 and FFHQ at 64x64, comparing a standard full-resolution flow-matching U-Net, a fixed-radius local U-Net, and this RG pyramid at matched parameter counts and function evaluations. Measure FID, long-range pixel and feature correlations, wall-clock sampling time, peak activation memory, and scaling from 64x64 to 256x256. The expected signal is lower FID and better correlations than fixed-radius local flow matching, with near-linear cost in pixel count and substantially lower memory than global attention. A particularly strong result would be preserved correlations at separations larger than the finest-level receptive field and improved FID at equal sampling FLOPs.

Verification

Failed on benchmark

Stage 1 · Toy mechanism gate: Passed ✓

Stage 2 · Mechanism transferred to benchmark: Not reproduced ✗

Stage 2 · Practical benchmark result: No measurable effect

Methodology: 8 paired seeds, permutation test (p<0.05) against a learning-rate-tuned baseline. How verification works

Stage 1 — Mechanism check agent confidence 8/10

Built a self-contained RG locality toy verification and a PyTorch coarse-to-fine pyramid flow-matching MVP. The three mechanism predictions were confirmed: required radius fit R versus 1/Lambda with R2=0.9996 and coefficient of variation of Lambda*R=3.7%; radius versus log(1/epsilon) had R2=0.9964; and Lambda=pi/a produced exactly constant cell radius 4 across six levels. The fixed-radius-8 operator error rose from 0.00024 at Lambda=1 to 0.742 at Lambda=0.1, while the selected RG radius kept error near 0.02. The neural toy showed lower pyramid mean velocity MSE (0.609 versus 0.875) and slightly better long-range correlation (0.075 versus -0.044), but it was not parameter-matched and was too small/short-trained to claim a generative-quality win.

Agent confidence: 8/10

Baseline: Operator fixed radius 8: error 0.00024 to 0.742 as Lambda decreases; neural velocity MSE 0.875, d=16 correlation -0.044, 3,281 parameters.
Idea: RG radius sweep: R*Lambda mean 4.248, CV 0.037; log-tolerance fit R2 0.9964; rescaled cell radius 4 at all levels; neural velocity MSE 0.609, d=16 correlation 0.075, 7,083 parameters.

Limitations: No CIFAR-10 or FFHQ experiment, FID, ODE sampling benchmark, memory benchmark, scaling study, or parameter/FLOP-matched neural comparison was performed. The toy kernel assumes exponential locality and therefore verifies the claimed scaling mechanism rather than the full paper theorem.

How to run: python3 rg_pyramid_toy.py && /home/maxwelhelp/main/bin/python3 rg_pyramid_flow.py

Stage 2 — Benchmark vs. tuned baseline (arXiv:2608.23696) Sep 2, 2026

Ahead of the baseline (−0.3%) but not statistically significant (p=0.4054, wins 4 / 8 paired seeds).

Benchmark: Multitoken_diffusion
Model: custom_local_vs_rg_pyramid
Paired seeds: 8
Baseline mean: 0.5488
Idea mean: 0.5474
Effect (Δ): -0.0014 (−0.3%; negative = idea better)
Wins: 4 / 8 paired seeds
p-value: 0.4054 (permutation test, 20 000 shuffles)
Smallest detectable effect: ±0.6%
Mechanism: Not confirmed ✗
Practical effect: No effect
Baseline tuning: swept over 3 configs

Limitations:

The benchmark used the registered synthetic multitoken diffusion track rather than CIFAR-10 or FFHQ, and tested only DIM=8 with a compact radius-1 convolutional architecture. No FID, ODE sampling wall-clock, activation-memory, or resolution-scaling study was performed. Evaluation was forced to CPU after a shared-GPU Conv1d execution-engine failure; training still used the benchmark's GPU-to-CPU fallback.

How to run: python3 stage2_bench.py

Verdict computed by deterministic test code from paired-seed statistics — not by the language model.

Stage 2 — Benchmark Sep 1, 2026 latest Failed ✗

Agent confidence: 10/10

Implemented RG Pyramid Flow Matching as a dyadic pooled coarse-conditioning model with a local fine residual field, compared against a matched radius-1 local convolutional baseline on the registered multitoken_diffusion track. The idea achieved MSE 0.54740 versus baseline 0.54884, delta_mean -0.00144, but p=0.40545, so this is no measurable effect rather than a significant win. The behavioral signature also failed: distant sensitivity was 0.0 for both systems, so the claimed long-range transfer was not quantitatively confirmed.

Baseline: mean MSE 0.5488443524; std 0.0252618988; best lr 0.006, epochs 12, hidden 32; 8 paired seeds
Delta mean: -0.0014431998 (idea lower is better)
Idea: mean MSE 0.5474011526; std 0.0256864126; best lr 0.006, epochs 12, hidden 32; 8 paired seeds
Idea wins: 4/8
Mechanism signature: confirmed=false; observed distant sensitivity idea 0.0, baseline 0.0
P value: 0.40545

Benchmark result