# Coxeter Folding Reversible Recurrence

- ID: 601
- Canonical URL: https://synthcore.org/idea/601/coxeter-folding-reversible-recurrence
- API JSON: https://synthcore.org/api/idea/601.json
- API Markdown: https://synthcore.org/api/idea/601.md
- Verification status: mech_ok_no_baseline
- Source: [arXiv:2607.08901](https://arxiv.org/abs/2607.08901)
- Category: dynamics
- Solves: memory, stability, speedup
- ML areas: rnn, ssm, transformer, memory, inference-speedup
- Math tags: dynamical-systems, geometry, linear-algebra
- Ratings: usefulness 6/10; difficulty 5/10; novelty 7/10

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

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

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

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

- Status: mech_ok_no_baseline
- Mechanism evidence: yes
- Mechanism confirmed: yes
- Practical verdict: harms
- Verdict: 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.

### Mechanism check

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

### Practical benchmark

- Paired seeds: 8
- Baseline mean: 0
- Idea mean: 0
- p-value: 0.0081
- Paired wins: 0/8
- Benchmark verdict: idea worse (significant)

## Artifacts

- [bench_report.json](https://synthcore.org/code/1407/bench_report.json)
- [benchmark.py](https://synthcore.org/code/1407/benchmark.py)
- [benchmark_results.json](https://synthcore.org/code/1407/benchmark_results.json)
- [experiment.py](https://synthcore.org/code/1407/experiment.py)
- [report.md](https://synthcore.org/code/1407/report.md)
- [report_bench_2026-09-04T204801.md](https://synthcore.org/code/1407/report_bench_2026-09-04T204801.md)
- [results.json](https://synthcore.org/code/1407/results.json)
- [stage2_bench.py](https://synthcore.org/code/1407/stage2_bench.py)
- [Download all files as ZIP](https://synthcore.org/download/1407)

## Disclaimer

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