△ Mechanism confirmed, baseline not beaten 2026

Coxeter Folding Reversible Recurrence

Implementation & benchmark of arXiv:2607.08901 — Integrability of Cauchy problems for discrete conformal maps and circle patterns

Usefulness6/10
Difficulty5/10
Novelty7/10

Source paper: Integrability of Cauchy problems for discrete conformal maps and circle patterns arXiv:2607.08901 ⓘ · analyzed Aug 30, 2026

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

Idea description

Build a recurrent block as a fixed or learned ordering of local vertex foldings, mirroring the paper's identification of staircase solution maps with Coxeter elements of a folding group. Each folding changes one polygon coordinate by a rational cross-ratio completion while leaving all other coordinates unchanged. The resulting structured recurrence is reversible and can support constant-memory backpropagation by recomputing folds in reverse order.

Formulas

$$p'_k=p_k\quad\text{for }k\not\equiv j\pmod n,\qquad [p_{j-1},p_j,p_{j+1},p'_j]=-1$$
$$p'_j=\frac{(p_j-p_{j+1})p_{j-1}-(p_{j-1}-p_j)p_{j+1}}{(p_j-p_{j+1})-(p_{j-1}-p_j)}$$
$$F_j\circ F_j=\mathrm{Id},\qquad S=F_{j_L}\circ\cdots\circ F_{j_1},\qquad S^{-1}=F_{j_1}\circ\cdots\circ F_{j_L}$$
$$e_T=\frac{\|S^{-1}(S(p))-p\|_2}{\|p\|_2}$$

Mathematical statement

Let p=(p_1,...,p_n) be a quasi-periodic polygon with p_{k+n}=p_k+T, where T is the complex monodromy. Folding at vertex j defines F_j by p'_k=p_k for k not congruent to j modulo n, while p'_j is selected so that [p_{j-1},p_j,p_{j+1},p'_j]=-1. Since the neighbors remain fixed, applying the same local folding again restores the original vertex on the nonsingular domain, so F_j is an involution. A zigzag schedule j_1,...,j_L produces S=F_{j_L} composed with ... composed with F_{j_1}; its inverse uses the reverse schedule. The paper identifies these structured compositions with Coxeter elements, rather than arbitrary recurrent transitions.

Implementation notes

Implement a recurrent block whose hidden state is an n-point complex polygon, optionally augmented with ordinary feature channels. Choose a periodic fold schedule j_1,...,j_L corresponding to a staircase; begin with a fixed alternating schedule and later learn a soft categorical distribution over schedules. At fold j, read the three neighboring points, compute the new point using the displayed rational expression, and leave every other point unchanged. Apply affine gauge normalization after each full Coxeter cycle because translation and complex scaling are nuisance symmetries. For memory-efficient training, do not save intermediate activations: during backward reconstruction, rerun the folds in reverse order, using the same involution. A small learned input-injection network may act once per cycle, followed by projection back onto the fold-generated manifold. The fold rule, quasi-periodic indexing, and reverse-order inverse are taken from the paper; learned schedules and feature readouts are adaptations. First run sequential MNIST or a synthetic polygon-dynamics task, comparing a GRU and a reversible coupling layer at equal hidden width. Measure activation memory, forward-reverse reconstruction error, gradient norm versus sequence length, and the largest finite-time Lyapunov exponent. The predicted signature is a sharp failure boundary when a fold denominator approaches zero; away from that boundary, e_T should remain near floating-point roundoff and memory should be nearly independent of sequence length. An integrable schedule should also show lower long-horizon Jacobian growth than a randomly ordered fold schedule.

Verification

Mechanism confirmed, baseline not beaten

Stage 1 · Toy mechanism gate: Passed ✓

Stage 2 · Mechanism transferred to benchmark: Confirmed ✓

Stage 2 · Practical benchmark result: Significantly worse ✗

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

Stage 1 — Mechanism check agent confidence 7/10

Built a complex-polygon Coxeter-style fold recurrence with fixed alternating schedule, exact reverse scheduling, denominator diagnostics, and a GRU memory comparison. Single-fold involution and one-cycle reverse reconstruction were at floating-point roundoff in float64; repeated float32 schedules accumulated error, and the singularity sweep showed the expected blow-up as the denominator approached zero. The reversible effect is real, but constant-memory training was not implemented because the MVP uses ordinary autograd; the memory result is therefore a native-unroll comparison, not proof of constant-memory backpropagation.

Agent confidence
7/10
Baseline
CPU GRU, batch=32, sequence length=32: 692224 native-autograd saved bytes; 291 saved tensors.
Idea
CPU fold chain, 32 folds: 86016 native-autograd saved bytes; 418 saved tensors; reverse reconstruction relative error 2.248847158625722e-05. Float64 reverse errors were 4.50e-16 at 8 steps, 7.01e-15 at 40, and 2.27e-11 at 160; float32 errors were 3.32e-07, 1.28e-05, and 3.11e-02 respectively. Near-singular folded magnitude grew from 2.03 at denominator 0.209 to 2.16e8 at denominator 2.09e-9.

Limitations: No learned schedule, input injection, affine gauge normalization, sequential-MNIST/task loss, custom reversible backward, or true constant-memory training was tested. CUDA encountered CUDNN_STATUS_INTERNAL_ERROR_HOST_ALLOCATION_FAILED, so the benchmark used its CPU fallback.

How to run: python3 experiment.py && /home/maxwelhelp/main/bin/python3 benchmark.py

Stage 2 — Benchmark vs. tuned baseline (arXiv:2607.08901)

Significantly WORSE than the tuned baseline (+151575.4%, p=0.0081, wins 0 / 8 paired seeds).

Benchmark
Dynamics forecasting
Model
rnn_small
Paired seeds
8
Baseline mean
0.0004
Idea mean
0.6313
Effect (Δ)
0.6309 (+151575.4%; negative = idea better)
Wins
0 / 8 paired seeds
p-value
0.0081 (permutation test, 20 000 shuffles)
Smallest detectable effect
±21087.5%
Mechanism
Confirmed ✓
Practical effect
Hurts
Baseline tuning
swept over 3 configs
Limitations:

Only the built-in dynamics task was tested. The custom reversible backward pass and constant-memory training were not implemented; the benchmark used ordinary autograd. Learned schedule selection, sequential MNIST, and long-horizon memory/speed measurements were not tested.

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 latest Failed ✗

Agent confidence: 9/10

Implemented a Coxeter folding recurrent model and evaluated it on the structurally matched dynamics track using the required paired 8-seed protocol, baseline sweep, and shared learning-rate union. The fold reversibility signature was confirmed quantitatively, but task MSE was dramatically worse than the tuned GRU: 0.631347 versus 0.000416, with significant degradation (delta_mean 0.630931, p=0.0081).

Baseline
dynamics/rnn_small, best lr=0.01: test MSE mean 0.00041624879668233916, std 0.00018933904234880896
Comparison
idea minus baseline mean delta 0.6309308672862244; 0/8 idea wins; permutation p-value 0.0081; verdict idea worse (significant)
Idea
CoxeterFoldRNN, best lr=0.01: test MSE mean 0.6313471160829067, std 0.09825334037840372

Benchmark result

Significantly WORSE than the tuned baseline (+151575.4%, p=0.0081, wins 0 / 8 paired seeds).

Benchmark
Dynamics forecasting
Model
rnn_small
Paired seeds
8
Baseline mean
0.0004
Idea mean
0.6313
Effect (Δ)
0.6309 (+151575.4%; negative = idea better)
Wins
0 / 8 paired seeds
p-value
0.0081 (permutation test, 20 000 shuffles)
Smallest detectable effect
±21087.5%
Mechanism
Confirmed ✓
Practical effect
Hurts
Baseline tuning
swept over 3 configs
Limitations:

Only the built-in dynamics task was tested. The custom reversible backward pass and constant-memory training were not implemented; the benchmark used ordinary autograd. Learned schedule selection, sequential MNIST, and long-horizon memory/speed measurements were not tested.

How to run: python3 stage2_bench.py

Artifacts

Implementation overview ⬇ Download all as ZIP 8 files · code, reports and structured results