---
license: mit
tags:
- icml2026-repro
- paper-l35QweVxgn
- continual-learning
- learning-theory
---

# Reproduction code — *On the Theory of Continual Learning with Gradient Descent for Neural Networks*

Clean-room NumPy reimplementation and full sweep harness for the ICML 2026 submission
[`l35QweVxgn`](https://openreview.net/forum?id=l35QweVxgn) ([arXiv:2510.05573v2](https://arxiv.org/abs/2510.05573)),
Taheri, Ghosh & Mazumdar.

**The write-up lives in the Trackio logbook:**
[🚀 `nmaher/repro-on-the-theory-of-continual-learning-with-gradient-descent-for-neural-networks`](https://huggingface.co/spaces/nmaher/repro-on-the-theory-of-continual-learning-with-gradient-descent-for-neural-networks).
This repo is the code and the raw numbers behind it.

## Layout

```
code/      the reimplementation and all eight sweep drivers
results/   one JSON per driver — every logged run, plus summary.json (all fitted slopes)
figs/      every figure as standalone HTML + PNG + the CSV it was drawn from
poster/    the 60"×36" conference poster (HTML source, print PDF, preview PNG)
```

| File | Claims | What it does |
|---|---|---|
| `code/clcore.py` | — | The model, the XOR-cluster data generator, full-batch GD, and the closed-form linear-loss solver. Everything else imports this. |
| `code/exp1_scalings.py` | 1 | Plain full-batch GD; forgetting vs $n$, $m$, $K-k$, $\eta$, $T$ |
| `code/exp2_mechanism.py` | 1, 2 | Closed-form solver; splits forgetting into `first_order` / `remainder` / `fo_fluct` / `fo_mean`, plus the mean-overlap control |
| `code/exp3_regime.py` | 2, 3, 6 | Prescribed-path sweep + 3 condition-breaking arms; the $\eta T$ horizon grid; the $4\times4$ $(n,m)$ joint grid |
| `code/exp4_gengap.py` | 4, 5 | Measured delayed generalization gap vs both bound right-hand sides |
| `code/exp5_etaT_needed.py` | 2 | Bisection for the smallest $\eta T$ that fits one task, over $(d,m)$ |
| `code/exp6_noise.py` | 3 | Cluster-noise control, $\sigma_c \in [0.1, 4.0]$ |
| `code/exp7_decomp_mc.py` | 6 | Monte-Carlo control on the term the decomposition drops |
| `code/exp8_nonvacuous.py` | 4, 5 | The low-$\eta$ corner where the exponential prefactors fall to $O(1)$ |
| `code/analyze.py` | all | Reads every `results/exp*.json`, fits every log–log slope, writes `results/summary.json` |
| `code/figures.py` | all | Reads `summary.json`, writes `figs/*.html` and `figs/*.csv` (set `CL_FIG_PNG=1` for PNGs) |
| `code/runall.sh` | — | Runs the drivers in order, skipping any whose JSON already exists |

The poster in `poster/` is a posterly (MIT, © 2026 Ruishuo Chen) landscape 4-column
build; `poster/BUILD_NOTES.md` records the canvas, palette and gate decisions, and
`poster/poster.pdf` is the print-ready file. It clears `preflight`, `style`, `measure` and
`polish --strict` (column spread 0.00 px).

## Reproducing

```bash
pip install numpy plotly
cd code
OMP_NUM_THREADS=1 CL_NPROC=3 ./runall.sh    # ~2.8 h on one CPU box
python analyze.py && python figures.py
```

Every driver seeds from an integer and is deterministic. No GPU, no trained weights to
download: the network state is a `float64` $m\times d$ matrix regenerated from its seed in
under a second, so the seed *is* the checkpoint.

**Memory.** `clcore.out()` and `clcore.gd_step()` multiply in row blocks of `CL_ZBLOCK`
(default 4096) rows so peak RSS stays under ~160 MB per worker even at $m=10^5$. This was
not a premature optimization — the unblocked version exhausted 16 GB twice. Lower
`CL_ZBLOCK` if you are tighter on memory; raise it for speed.

## What was checked

Six claims, each with an audit and at least one control that breaks a stated hypothesis:

1. **Theorem 1's closed-form forgetting bound** — term structure and all eight exponents. *Supported.*
2. **The parameter regime** $n=\widetilde\Theta(d^2K)$, $m=\widetilde\Omega(d^8K^4)$, $\eta T=\Theta(d^2)$ — *two of three conditions load-bearing; the width condition is loose by ~$10^{14}$.*
3. **Theorem 2's uniform misclassification error** — *error half yes (0 errors in 32/32 runs); loss half needs the full horizon.*
4. **Theorem 3's delayed generalization gap** — *holds, but vacuously everywhere reachable ($10^{826}$ vs $1.7\times10^{-4}$).*
5. **Theorem 4's improvement for self-bounded losses** — *supported; $10^{756}$ tighter at the base point.*
6. **The test-time forgetting decomposition** — *$n$ controls forgetting, $m$ does not; the dropped term is unresolved.*

Full reasoning, figures and caveats are on the corresponding pages of the logbook.

## Provenance

The authors release three Jupyter notebooks at
[`hosseinta2/continual-learning-with-neural-nets`](https://github.com/hosseinta2/continual-learning-with-neural-nets/tree/5e7329081bc948d4aa4159def5feed50160411b1)
(audited at commit `5e73290`). They contain no reusable module, no config or seed files and
no sweep driver, so nothing here is derived from them except the data generator and model
definition, which were cross-checked line-by-line against `continual_learning_codes-XOR.ipynb`.