# RG Pyramid Flow Matching

- ID: 2708
- Canonical URL: https://synthcore.org/idea/2708/rg-pyramid-flow-matching
- API JSON: https://synthcore.org/api/idea/2708.json
- API Markdown: https://synthcore.org/api/idea/2708.md
- Verification status: failed_benchmark
- Source: [arXiv:2608.23696](https://arxiv.org/abs/2608.23696)
- Category: architecture
- Solves: speedup, memory, accuracy
- ML areas: diffusion, diffusion-sampling, cnn, memory
- Math tags: dynamical-systems, pde, probability, functional-analysis
- Ratings: usefulness 8/10; difficulty 6/10; novelty 6/10

## 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.

## 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}\).

## Key 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)}.$$

## 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

- Status: failed_benchmark
- Mechanism evidence: yes
- Mechanism confirmed: no
- Practical verdict: no_effect
- Verdict: 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.

### Mechanism check

- Verdict: 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.
- Confidence: 8/10
- 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.

### Practical benchmark

- Paired seeds: 8
- Baseline mean: 0
- Idea mean: 0
- p-value: 0.40545
- Paired wins: 4/8
- Benchmark verdict: no measurable effect

## Artifacts

- [bench_report.json](https://synthcore.org/code/1027/bench_report.json)
- [flow_results.json](https://synthcore.org/code/1027/flow_results.json)
- [report.md](https://synthcore.org/code/1027/report.md)
- [report_bench_2026-09-01T185742.md](https://synthcore.org/code/1027/report_bench_2026-09-01T185742.md)
- [results.json](https://synthcore.org/code/1027/results.json)
- [rg_pyramid_flow.py](https://synthcore.org/code/1027/rg_pyramid_flow.py)
- [rg_pyramid_toy.py](https://synthcore.org/code/1027/rg_pyramid_toy.py)
- [stage2_bench.py](https://synthcore.org/code/1027/stage2_bench.py)
- [Download all files as ZIP](https://synthcore.org/download/1027)

## Disclaimer

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