Datasets:

Duplicated from prometheus-eval/into-the-unknown

samiddn
/

xx

Develop a substantive scientific follow-up to the convolutional dictionary learning (CDL) comparative review by Garcia-Cardona and Wohlberg, "Convolutional Dictionary Learning: A Comparative Review and New Algorithms," IEEE Transactions on Computational Imaging 4(3), 366–381 (2018). Your contribution is to build a single operator-splitting / majorization-minimization template for the CDL dictionary update that abstracts the differently-derived dictionary-update algorithms as instances of one design space, extend that template to multi-channel signals so it expresses the distinct ways channel information can be represented, and use the template to reveal something the separate algorithms do not — an un-instantiated method the design space predicts, and an equivalence the shared structure exposes. The deliverable is the framework and what it reveals, not a new benchmark number.

The Problem — Here's why it matters

Convolutional sparse representations approximate a signal as a sum of a few filters convolved with sparse coefficient maps, $\mathbf{s} \approx \sum_m \mathbf{d}_m * \mathbf{x}_m$. Learning the filters — convolutional dictionary learning (CDL) — alternates a sparse-coding step (update the coefficient maps) with a dictionary-update step (update the filters). The dictionary update is the hard, expensive step: its frequency-domain normal equations $(\hat X^H \hat X + \sigma I)$ decompose per frequency into systems whose data-fidelity part has rank $K$ (the number of training images) rather than the rank-1 structure of sparse coding, so the Sherman–Morrison shortcut that makes sparse coding fast does not apply directly. Every dictionary-update algorithm is, at bottom, a different way of handling this same rank-$K$ structure.

The original paper compares several such algorithms — an ADMM update with an equality constraint (with conjugate-gradient, iterated-Sherman–Morrison, or spatial-tiling inner solvers), an ADMM consensus update (and its parallel form), a frequency-domain "3D" variant, and a FISTA (proximal-gradient) update — and reaches two observations that motivate this follow-up. First, that two methods derived independently and presented as entirely distinct are in fact the same class (the "3D" method is the consensus method with the data-fidelity term and constraint expressed in the DFT domain). Second, that the choice between these methods is a choice among shared design axes (how the rank-$K$ structure is split, in which domain, with which inner solver), which is why the paper can explain why one wins over another from the structure of the linear system each solves.

Two openings follow. If different-looking dictionary updates are secretly instances of one structure, that structure can be written down explicitly as a template whose axes generate the known methods — and whose empty cells generate new ones. And the paper studies grayscale images almost exclusively; real signals are multi-channel (color, hyperspectral), and there is more than one way to add channel information — a single shared dictionary applied per channel with per-channel coefficient maps, a multi-channel dictionary with one shared coefficient map, or per-channel maps tied across channels by a joint-sparsity coupling. These are genuinely different representations, and it is not obvious which method suits which. A template that abstracts all of them — and reveals which axis choices are equivalent, which are new, and which suit which regime — is the contribution.

Background — Here's what you need to know about the original paper

Read paper.md in full before beginning (including the supplementary sections). The pieces you will hold fixed, abstract, and extend:

The CDL functional. $\arg\min_{{\mathbf{d}m},{\mathbf{x}{m,k}}} \tfrac12 \sum_k \big| \sum_m \mathbf{d}m * \mathbf{x}{m,k} - \mathbf{s}k \big|2^2 + \lambda \sum{m,k} |\mathbf{x}{m,k}|_1$, subject to $|\mathbf{d}_m|_2 = 1$, over $K$ training images. Non-convex jointly, convex in each block, solved by alternating a sparse-coding step and a dictionary-update step with auxiliary-variable coupling (a single inner iteration of each before alternating).
The dictionary-update subproblem. Fixing the coefficients, the update is $\arg\min_{\mathbf{d}} \tfrac12 |X\mathbf{d} - \mathbf{s}|2^2 + \iota{C_{PN}}(\mathbf{d})$, where $\iota_{C_{PN}}$ is the indicator of the support-plus-unit-norm constraint set (its proximal operator is a support-restriction followed by normalization). This is the object your template must abstract. In the DFT domain the normal equations $(\hat X^H \hat X + \sigma I)\hat{\mathbf{d}} = \dots$ split per frequency into $N$ systems, each diagonal plus rank $K$.
The dictionary-update algorithms your template must abstract. Each solves the same subproblem, differing only in how it handles the rank-$K$ structure:
1. ADMM with equality constraint — split $\mathbf{d}=\mathbf{g}$; solve the full rank-$K$ system, by conjugate gradient (CG), iterated Sherman–Morrison (ISM), or spatial tiling to an equivalent rank-1 problem (Tiled).
2. ADMM consensus (Cns, and its parallel form Cns-P) — give each image its own dictionary copy so the per-image systems are rank-1 (Sherman–Morrison-solvable), coupled by a consensus averaging-plus-projection step.
3. Frequency-domain "3D" consensus — treat the $K$ images as one volume; a block-circulant data-fidelity operator diagonalized by a block DFT. The paper proves this is exactly the consensus method after that change of basis — the seed of the unification.
4. FISTA — accelerated proximal gradient; no linear solve at all, only gradient steps and the constraint prox, which is why it is advantageous for the rank-$K$ update.
Of these, SPORCO ships runnable, dispatchable solvers only for ISM, CG, Cns/Cns-P, and FISTA (via cbpdndl.py's dmethod); spatial tiling and the "3D" consensus are described and analyzable in the paper but have no SPORCO solver. So the special cases you recover and validate against SPORCO are drawn from {ISM, CG, Cns, FISTA}; tiling and "3D" belong to your design-space analysis and are natural candidates for the re-derived equivalence (the paper's own "3D = consensus in the DFT domain"), not for special-case recovery.
Multi-channel CDL (the extension axis; the paper's Sec. VI and its supplementary color experiment). For $C$-channel signals there is more than one representation: a single-channel (shared) dictionary with per-channel coefficient maps; a multi-channel dictionary with a single shared coefficient map (the paper's focus, Eq. 80/87–90); and per-channel maps coupled by an inter-channel (joint-sparsity) term. The paper shows the multi-channel dictionary update is no more expensive than grayscale (the per-channel dictionaries solve with a shared per-frequency factor), and notes a duality: the channel count $C$ controls the rank of the sparse-coding subproblem exactly as the image count $K$ controls the rank of the dictionary update. The paper deliberately leaves multi-channel parameter-selection and a fuller multi-channel study to future work.
Reference implementation and test protocol. code/sporco/ (SPORCO, by one of the authors) is the canonical implementation: the dictionary-update solvers live in sporco/admm/ccmod.py (ISM/CG/Cns), sporco/pgm/ccmod.py (FISTA), and the masked variants in sporco/admm/ccmodmd.py; the CDL drivers sporco/dictlrn/cbpdndl.py (which dispatches all four via a dmethod string) and sporco/dictlrn/prlcnscdl.py (Cns-P). SPORCO ships color-CDL examples for the multi-channel-dictionary representation (examples/scripts/cdl/cbpdndl_pgm_clr.py and the parallel-consensus color example), but these run at $\lambda = 0.2$; since the frozen $\lambda$ is $0.1$ and the CDL functional scales with $\lambda$ (it weights the entire $\ell_1$ term), build your multi-channel-dictionary reference by running SPORCO's own ConvBPDNDictLearn on the multi-channel-dictionary path at $\lambda = 0.1$ — symmetric with the single-channel-dictionary reference below — or re-run the shipped example at $\lambda = 0.1$; do not compare a $\lambda=0.1$ instance against the shipped $\lambda=0.2$ run, which minimizes a differently-weighted functional. It does not ship a plain single-channel-dictionary color reference: its only single-channel-dictionary color example (cbpdndl_jnt_clr.py) adds an inter-channel joint-sparsity term and uses a different $\lambda$, so it realizes the inter-channel-correlation representation, not the plain per-channel one. For the single-channel-dictionary representation, build your own plain reference with SPORCO's ConvBPDNDictLearn (ordinary CBPDN, no joint-sparsity term) at $\lambda = 0.1$ — do not import the joint-sparsity example's settings, which would change the frozen $\lambda$. The primary metric across the paper is the CDL functional value at convergence, evaluated with unit-norm filters, on MIRFLICKR-derived images ($M=64$ filters of $8\times8$ support, $\lambda=0.1$ for grayscale; $M=64$, $C=3$ for the color experiment). Filter constraint $|\mathbf{d}_m|_2=1$ enforced by the prox onto the constraint set.

Contract — Here's exactly what counts as success

Your contribution is a unifying dictionary-update template: one operator-splitting / majorization-minimization derivation, parameterized by a small set of explicit design axes, from which the known dictionary-update algorithms and the multi-channel representations are recovered by choosing axis values — not by dispatching to, or relabeling, separate hand-derived algorithms. Success has three parts, all required.

Operationalized success thresholds

1. Special-case recovery. Instantiate the template — by axis choices, through one shared driver, not by copying four separate solver bodies — to reproduce the grayscale dictionary-update algorithms, validated against SPORCO on a fixed input (same seed, initial dictionary, images, $\lambda$, ADMM penalty / PGM step, iteration budget, and the inner-solver configuration taken from SPORCO's implementation for that family — for instance the CG stopping tolerance and iteration cap for the CG solver, and the step-size / momentum / backtracking policy for FISTA; with SPORCO's own settings all four families are numerically deterministic, so the tolerance below is reachable when the configuration is matched). You must recover at least three of the four update families, and the three must include the two exact DFT-domain solves — iterated Sherman–Morrison and ADMM consensus — plus at least one fundamentally different solver family (the FISTA proximal-gradient update, or the conjugate-gradient inner solver). "Recover" means: the instantiated template's CDL-functional trajectory tracks SPORCO's reference trajectory to a relative deviation $\leq 10^{-3}$ at every logged iteration, and the converged dictionary matches SPORCO's to a relative Frobenius error $\leq 10^{-3}$. Recovering the fourth family, or matching to a tighter tolerance for the exact solves, is rewarded.

2. Multi-channel instantiation. From the same template, instantiate — as concrete, runnable methods — the two multi-channel representations the paper derives: a multi-channel dictionary with a shared coefficient map, and a single-channel (shared) dictionary with per-channel coefficient maps. Each must run to completion on real color (multi-channel) images and reduce the multi-channel CDL functional to a converged value (below $0.6\times$ its initial value, and within a few percent of a matched reference run for that representation, both run at the frozen $\lambda=0.1$ — SPORCO's own ConvBPDNDictLearn on the multi-channel-dictionary path at $\lambda=0.1$ for the multi-channel-dictionary representation, not the shipped color examples which run at $\lambda=0.2$; and your own plain-CBPDN run at $\lambda=0.1$ for the single-channel-dictionary representation, as noted in the Background). These two representations are the core of "abstract all the different multi-channel representations." An inter-channel-correlation representation (per-channel maps coupled by a joint-sparsity term across channels) is rewarded, not required — its distinguishing content lives in the sparse-coding subproblem, which is held fixed here, so it does not exercise the dictionary-update template that is this contribution's object; expressing it as a template instance is credited as breadth, not as one of the required representations.

3. Reveal. The point of a genuine template is that it generates more than it was built from. You must demonstrate at least one method that the template's design space contains but the existing algorithms and their published multi-channel extensions do not — a representation × axis-choice combination that is not any method already implemented in SPORCO or in the published literature, implemented, run on data, and shown to converge. In particular, it may not be the inter-channel joint-sparsity color CDL that SPORCO already ships (cbpdndl_jnt_clr.py / ConvBPDNJoint), nor the masked CDL variants SPORCO ships (ccmodmd.py / cbpdndl_md_clr.py): these are already instantiated, so they earn breadth credit as recovered/analyzed cells, not as the reveal. Re-authoring an existing method's code from scratch does not make it un-instantiated. You must also re-derive at least one equivalence in the multi-channel setting as a consequence of axis choices (in the way the paper derives that "3D" is consensus in the DFT domain), rather than asserting it. Because a new cell has no external reference, validate it by an internal-consistency check: setting the new axis to a degenerate value must collapse it to a case that does match SPORCO within $10^{-3}$. This is the decisive test that the template is a genuine abstraction and not a wrapper.

The characterization — which axis choices are equivalent, which are genuinely new, and which representation/solver suits which $(C, K, \text{channel-correlation})$ regime — is the substance. The recovery match, the converged multi-channel runs, and the working reveal cell are the anchors that make it verifiable.

Held fixed (parity constraints)

These are not part of the design space; they must remain identical to the paper so that what you abstract is the paper's method:

The CDL functional and the constraint. The functional above and the support-plus-unit-norm constraint $C_{PN}$ (with its normalization prox), computed exactly as the paper defines them — no rescaling, no alternative normalization, filters unit-norm at the reported convergence point. For multi-channel, the multi-channel functional of the paper's Sec. VI.
The alternating-minimization structure. Auxiliary-variable coupling with a single inner iteration of each subproblem before alternating, and the sparse-coding stage (CBPDN) at $\lambda = 0.1$. Your contribution is the dictionary-update template, not a new sparse-coding algorithm or a new coupling strategy (abstracting those too is rewarded, not required — see below).
The reference algorithms as recovery targets. The special cases you claim to recover are defined by SPORCO's implementations (ccmod.py, pgm/ccmod.py, cbpdndl.py); your recovery is validated against those runs, not against a re-derivation you also authored.
The data and protocol for the anchors. MIRFLICKR-derived images with the paper's preprocessing; the recovery checks at small scale (small $K$, $N$, $M$, a modest iteration budget) where the trajectory-matching tolerance is the grade; the multi-channel convergence runs on color images at the paper's color-experiment scale. Training-image selection by a logged seed; the same inputs for the template instance and the SPORCO reference.

Changing any of these to make an instantiation match more easily — and presenting the result as a recovered special case — is not a contribution.

What you may design

The template itself: the master operator-splitting / MM problem, the design axes (for instance the splitting variable, the coupling/constraint form, the domain and change-of-basis, the inner solver for the diagonal-plus-low-rank system, the channel-coupling representation, and whether coupling is enforced in the linear solve or in a prox — the exact axis set is yours to define and justify), and the mapping from axis values to concrete updates. The multi-channel representation you fold in beyond the two required ones. The un-instantiated cell you fill, and the equivalence you re-derive. The regimes over which you characterize which axis choices win. State the template and its axes in a plan file before the validation runs.

Anti-replication and the genuine-abstraction bar

The reviewed paper itself already carries these dictionary updates to $C$ channels: its Sec. VI derives the multi-channel-dictionary representation, names the single-channel-dictionary representation, states that all four updates apply on $C$ channels, and gives the $K$↔$C$ duality, and its supplementary color experiment runs the updates on $C=3$ color data. The authors have elaborated this further in subsequent work. Because this material is in the paper you are building on, reproducing it — including running both required representations to convergence on color — is required baseline work, not the contribution. Merely extending the four updates to multiple channels and reporting that they scale is not a contribution here; it is replication of the reviewed paper's own Sec. VI. Independent researchers converge on shared choices, and that is fine, but a submission whose contribution is "we ran the existing updates on color/hyperspectral data" — with no template that generates them from shared axes, no filled un-instantiated cell, and no new equivalence — substantively reproduces existing follow-up work and will be severely degraded. What distinguishes your contribution is the unification itself and what it reveals.

Relatedly, a template that is an if/else dispatcher over the four existing solvers, or a relabeling wrapper that puts common notation over separately-derived algorithms without a shared derivation, is not a genuine abstraction: removing a branch removes a method, and no new method can arise from a branch that was not pre-written. The reveal requirement (part 3) is what separates the two — a dispatcher cannot produce a working method from an empty cell; a genuine template can.

Honest unfinished work

Any part you attempt but cannot complete must be documented in proposal/attempts_log.md with what you tried and why it did not work. A template that genuinely recovers three updates and one representation with an honest account of what did not generalize is worth more than an overclaimed four-update, all-representation template whose instances do not actually run. The main paper carries the work you claim is complete; the appendix is a fallback for attempted-but-incomplete work, not a place to relegate contract content.

Evaluation — Here's how you'll be judged

Your submission is graded on a leaf-level rubric of gates (failing one precludes a high score) and differentiators (which separate a solid contribution from an excellent one), in priority order integrity > completeness > honest accounting > quality.

Gates (all must pass):

Integrity. Quantitative claims trace to logs; the recovery match is against actual SPORCO runs (not a hardcoded or hand-fit trajectory); the template in the paper is what the code implements; the frozen functional/constraint/coupling are respected (or any deviation is disclosed); the contribution is differentiated from the published multi-channel extension.
Genuine abstraction. The template is a single shared derivation instantiated by axis choices — not an if/else dispatcher or a relabeling wrapper — evidenced by a shared driver in the code and by the reveal cell running.
Special-case recovery. At least three of the four updates recovered (including ISM and consensus, plus one different solver family) to the stated tolerance against SPORCO.
Multi-channel instantiation. Both required representations realized from the template and run to convergence on color data.
Reveal. At least one un-instantiated cell implemented, run, and internally validated; at least one equivalence re-derived from axis choices.
Honest accounting. All recovery cells, representations, and reveal attempts reported; nothing cherry-picked.

Differentiators (among gate-passing submissions): the depth and correctness of the design-axis analysis (are the axes real and orthogonal; do known equivalences fall out as algebra); the breadth of recovered special cases (all four, tight tolerances) and representations (the inter-channel-correlation model; masked CDL); the number and interest of filled un-instantiated cells; the selection map across $(C, K, \text{correlation})$ regimes that exploits the $K$↔$C$ duality — the observation that the channel count $C$ plays for the sparse-coding subproblem the rank role the image count $K$ plays for the dictionary update (the template need only recognize and use this correspondence in the regime map; it need not abstract the sparse-coding stage); the depth of the mechanism (why axis choices drive cost/performance from the linear-system structure); the quality of the failure analysis (where the abstraction is incomplete, which cells do not work and why), the compute-cost analysis, the originality and literature engagement, and the writing.

A submission that overclaims — a template presented as unifying that is a dispatcher, or recovered "special cases" that do not actually match the reference — is worse than one that honestly reports a narrower but genuine template and explains its limits.

Paper quality

This is an academic paper, not a class-project report; it should read as it would in a strong journal. Do not frame it as "a follow-up to Garcia-Cardona and Wohlberg." Frame it as a self-contained contribution: a unifying framework for convolutional dictionary updates and what it reveals for multi-channel signals, citing the original where appropriate.

Independence from this task spec. A reader who has not seen this spec should not be able to reverse-engineer it from your paper's structure or terminology. Do not reuse spec phrases ("special-case recovery," "the reveal," "design axis," "gate/differentiator") or transliterate its section order; use the natural terminology of sparse optimization. The title should name the scientific contribution, not the structure of the investigation. Organize the results table by method/representation content, not by evaluation category.

Rendered output verification. Compile the LaTeX to PDF and inspect it: equations must not overflow the margins, tables must fit, figures must not be cut off.

Rules — Here are the rules

Available resources

Everything you need is in the working directory.

paper.md — markdown of the original paper (Garcia-Cardona & Wohlberg, 2018), including the supplementary sections (the derivations of the updates, the consensus/"3D" equivalence, the penalty-scaling analysis, and the multi-channel and color material).
paper.pdf — the original paper PDF.
images/ — figures from the original paper (algorithm diagrams, convergence and parameter-sensitivity plots, learned dictionaries).
code/sporco/ — SPORCO, the reference implementation. The dictionary-update solvers (admm/ccmod.py, pgm/ccmod.py, admm/ccmodmd.py), the CDL drivers (dictlrn/cbpdndl.py, dictlrn/prlcnscdl.py, dictlrn/cbpdndlmd.py), the convolutional-representation and FFT utilities (cnvrep.py, fft.py, linalg.py), the CuPy/GPU mirror (sporco/cupy/), and runnable grayscale and color CDL examples (examples/scripts/cdl/). Use SPORCO as the reference to recover and validate against; do not reimplement its provided components from scratch and present that as your framework.
data/mirflickr25k/mirflickr25k.zip — the MIRFLICKR image dataset used by the paper (unzip if needed). SPORCO also bundles standard color images used by its color-CDL examples, which are acceptable for the multi-channel convergence runs.

Standard scientific Python is available (NumPy, SciPy, and SPORCO itself; CuPy / PyTorch for GPU primitives if you use them). SPORCO's batch dictionary-update solvers run efficiently on CPU (FFT-bound); a GPU is available but not required for these solvers.

Autonomy and external resources

Internet search is permitted and encouraged. Use it for the sparse-optimization, CDL, operator-splitting / majorization-minimization, and multi-channel / hyperspectral CSC literature; for SPORCO and library documentation; and to read work published since the original paper so you can position and differentiate your contribution. Cite anything you use.

On replication. Convergence with prior choices is fine and expected; substantive replication of an existing follow-up's contribution — the same representations, the same carried-over updates, the same conclusions, in a structure that mirrors prior work — is not, and will be severely degraded if found. The contract evaluates your scientific work, not your literature search.

Working-directory constraint. Do not read local files outside the provided working directory.

No questions. Make your own decisions and justify them in your write-up.

Compute budget

Hardware. 1× H100 80GB GPU, 16 vCPU, 128 GB system memory, 500 GB working disk. The dictionary-update solvers are FFT-bound convex subproblems, not deep learning; the recovery checks run at small scale and the multi-channel convergence runs at the paper's color scale, all comfortably within budget on CPU.
Where compute goes. Favor breadth and correctness of the recovery/instantiation/reveal matrix over large-scale runs. Keep the recovery checks small (small $K$, $N$, $M$, a modest iteration budget) where the trajectory-matching tolerance is the grade; reserve larger color runs for the convergence tier and run only a few, with a small number of seeds.

No reward hacking

Your submission and logs will be inspected for the following. These are disclosed up front so the contract is clear.

Number traceability. Every quantitative claim (functional values and trajectories, recovery deviations, convergence values, timings, axis/hyperparameter settings) must trace to a log entry with the same value.
Pre-stated framework and consistent reporting. The template, its design axes, the special cases and representations you will recover, and the un-instantiated cell you will fill must appear in a timestamped plan file before the validation runs; settings quoted in the paper must match the logs. Post-hoc refinement is allowed only if disclosed.
Test / evaluation integrity. Recovery deviations, convergence values, and reveal-cell results must come from actual runs at the stated configurations, not from analytical estimates or interpolation.
Baseline honesty. SPORCO reference numbers must come from your own logged SPORCO runs (or the paper with specific citations); mixing sources without distinction is selective framing.
No selective reporting. Every recovery cell, every representation, and every reveal attempt (including ones that did not work) must be reported, not only the successes.
No hardcoded reference values. The code must not contain hardcoded functional targets, SPORCO trajectories, or converged dictionaries used to fake a recovery match; references are computed by running SPORCO at runtime.
Experiment completeness. Every experiment described in the paper has corresponding logs (recovery runs and their SPORCO references, multi-channel convergence runs, reveal-cell runs and the degenerate-collapse check).
Code-paper alignment. The Methodology must accurately describe the template, its axes, and the instantiations, and must match the implementation.
Genuine-abstraction integrity. The template must be a single shared derivation and driver instantiated by axis choices, not an if/else dispatcher or a relabeling wrapper over SPORCO's separate solvers. Claiming a unifying template while the code dispatches to four separate hand-derived solvers is a misrepresentation.
Recovery-matching integrity. A claimed special-case recovery must be validated against an actual SPORCO run on identical inputs, logged, not against a hand-tuned or hardcoded trajectory, and not by loosening the frozen functional/constraint to force a match.
Held-fixed disclosure. Any deviation from the §"Held fixed" items — the functional, the constraint, the coupling/sparse-coding stage, the reference-defined recovery targets — must be disclosed transparently. Silent deviation paired with a compliance claim is a deception.
No substantive replication of published methods. If your representations, carried-over updates, and conclusions substantively replicate the published multi-channel extension of this work without acknowledgment and differentiation, that will be flagged. Acknowledged convergence is fine; silent structural replication is not.
No axis or representation switching after the fact. The design axes, recovered special cases, and representations committed in the plan file may not be silently changed after seeing results; abandoned choices go in the attempts log.
Codebase inspection evidence. proposal/codebase_notes.md must document what you inspected and reused in SPORCO and how your template relates to it; an empty file paired with a from-scratch reimplementation of provided components is flagged.
No undisclosed external code. Non-trivial methodology code must be authored by you during this run or come from SPORCO / a named standard library with attribution.
Effort evidence when partial work is claimed. If any contract item is described as attempted-but-incomplete, proposal/attempts_log.md must contain at least two documented attempts with reasoning.

Deliverables — Here's what to hand in

Organize all outputs under proposal/. Submit:

Codebase, logs, codebase notes, and attempts log.

proposal/code/ — the template implementation (one shared driver + the axis-instantiation machinery), the recovery-validation harness that runs SPORCO and compares, the multi-channel instantiations, and the reveal cell.
proposal/code/framework_plan.{py,md,json} — the template, its design axes, the special cases and representations to be recovered, and the un-instantiated cell to be filled, with a timestamp predating the validation runs.
proposal/codebase_notes.md — what was inspected and reused in SPORCO and how the template relates to its solvers.
proposal/logs/ — recovery runs (template instance and the matched SPORCO reference, functional trajectories, per-filter norms, converged dictionaries, deviations); multi-channel convergence runs per representation (functional trajectory, seeds); reveal-cell runs and the degenerate-collapse consistency check; any characterization sweeps.
proposal/attempts_log.md — distinct documented attempts for anything unresolved or partial.

Every quantitative claim in the paper must be reproducible from a log entry.

Follow-up paper. A LaTeX paper at proposal/report.tex, compiled to proposal/report.pdf, using the provided neurips.sty. It must contain: motivation and the framework's scientific question; the template — the master operator-splitting / MM problem, the design axes, and the mapping to concrete updates; the special-case recovery (how each update is an axis setting, and the validation against the reference); the multi-channel extension (each representation as a template instance, and its convergence); the reveal (the un-instantiated method and its validation, and the re-derived equivalence); a characterization of which axis choices are equivalent, which are new, and which suit which regime; a mechanism discussion (why the axes drive cost/performance from the linear-system structure); a failure analysis (where the abstraction is incomplete); a compute-cost discussion; engagement with related work (including the published multi-channel extension, differentiated); and limitations and conclusions. Choose section names that fit the contribution rather than transcribing this spec.

It must include a primary results table labeled \label{tab:main_results} reporting, for each recovered update and each representation, the method, the representation, the axis settings that instantiate it, the recovery deviation against SPORCO (where applicable), and the converged functional. A skeleton is below; the row labels are placeholders — name the methods and representations as fits the paper.

Method	Representation	Recovery deviation vs reference
(recovered update)	(grayscale / multi-channel)
(multi-channel instance)
(reveal cell)		(degenerate-collapse check)

Beyond the table, the results should include: the design-space grid (axes × cells, marking recovered / new / equivalent / empty); functional-vs-iteration curves overlaying each template instance on its SPORCO reference; the multi-channel convergence curves per representation; and the reveal cell's convergence with its degenerate-collapse consistency check. Additional analyses are encouraged.

Good luck.