# Task: Develop a Substantive Follow-up to "Parameterized Physics-informed Neural Networks for Parameterized PDEs"

## Objective — Here's what you're doing

Develop a substantive scientific follow-up to P²INN by Cho, Jo, Lim, Lee, Lee, Hong, and Park, "Parameterized Physics-informed Neural Networks for Parameterized PDEs," ICML 2024. P²INN solves a family of parameterized PDEs with a single network by **encoding the PDE coefficients into a latent representation** and decoding the solution from it, rather than treating the coefficients as extra input coordinates. But it conditions on the **PDE coefficients only**: the initial and boundary conditions are imposed through the loss, never represented as inputs to the parameter encoder — so a single trained model cannot be *queried* at a new initial condition or a new boundary condition, only at a new coefficient. Your contribution is to **extend the parameter encoder into a problem-specification encoder** that conditions jointly on the coefficients **and** the initial condition **and** the boundary condition, so that one model generalizes across all three — and, at the outer edge, across PDE types — and to establish, with a mechanism analysis, that a single shared model genuinely represents this broader family rather than merely memorizing the trained specifications.

This is not a "reach a target error on a fixed construct" task. The construct itself is what you broaden: the object of study is *what a single parameterized-PINN surrogate can be conditioned on and generalize over*, and the evidence you must produce is that the extended encoding represents the initial/boundary conditions in a way that generalizes to unseen ones — not that a number dropped on the same coefficient-only benchmark.

## The Problem — Here's why it matters

Parameterized PDEs must be solved at many points in a **problem-specification space** — not only many PDE coefficients, but many initial conditions (different sources, different starting profiles) and many boundary conditions (periodic, Dirichlet, Neumann, mixed). In design optimization, uncertainty quantification, and inverse problems the initial and boundary conditions vary as much as the coefficients do. Training one PINN per specification is prohibitive. P²INN amortizes across **coefficients**: a **parameter encoder** `g_{θp}` maps the coefficient vector `μ` to a latent `h_param`, a **coordinate encoder** `g_{θc}` maps `(x,t)` to `h_coord`, and a **decoder** `g_{θg}` maps the concatenation to the solution — one model covers a whole coefficient range and overcomes PINN "failure modes" (high convection, high reaction) that defeat a per-instance PINN.

But the initial condition and the boundary condition enter P²INN **only through the training loss** — the IC/data term and the periodic-boundary term — and are **fixed** for a given trained model. Nothing about the initial or boundary condition is an *input* to the encoder, so the model cannot be evaluated at a new IC or a new BC without retraining. This is the method's central representational limitation: it conditions on one axis of the specification (coefficients) and bakes in the other two. **The open question this follow-up addresses: can the parameter encoder be extended into a problem-specification encoder that conditions on the initial and boundary conditions as inputs — so that one model generalizes to unseen initial conditions, unseen boundary conditions, unseen coefficient/IC/BC combinations, and across PDE types — and can we show, mechanistically, that the extended encoding actually represents the specification rather than ignoring it or memorizing the trained set?** Whether initial and boundary conditions can be encoded in a form that generalizes (defining parameters, basis coefficients, sampled function values, or a learned function encoder), whether a single shared model can span more than one PDE family, and whether the generalization comes from the *structured* conditioning rather than from merely adding raw inputs, is exactly what a rigorous follow-up must establish.

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

Read `paper.md` in full before beginning. The components you will **hold fixed** and build on:

1. **The three-part factorization.** `u_Θ(x,t;μ) = g_{θg}([ g_{θc}(x,t) ; g_{θp}(μ) ])`: a **coordinate encoder** `g_{θc}` producing `h_coord`, a **parameter encoder** `g_{θp}` producing `h_param = g_{θp}(μ)`, and a **decoder** `g_{θg}` that consumes their **concatenation** and outputs the solution. The original P²INN coordinate encoder, decoder, and concatenation-based injection of `h_param` and `h_coord` must remain unchanged, including the reference `modvec` pathway, as specified under Held fixed. Architectural changes are restricted to the specification encoder. The three sub-networks are trained **jointly, end-to-end**, under one loss.

2. **The parameter encoder `g_{θp}` (the object you extend).** A small MLP (the `param_enc_layer_1..4` stack, `3 → 150 → 150 → 150 → 50`, `tanh` between layers, in `code/P2INN/model.py`) that maps the PDE coefficient vector `μ` (for the CDR family `μ = (β, ν, ρ)`) to `h_param ∈ ℝ^{50}`. **In the reference model its input is the 3-dimensional coefficient vector and nothing else.** Extending *what this encoder conditions on* — turning it from a coefficient encoder into a problem-specification encoder that also ingests the initial condition and the boundary condition — is the contribution.

3. **The training loss and how ICs/BCs enter it.** A weighted sum (equal weights, `=1` in code) of an **IC data-matching term** `cost_gt` (predicted vs. ground-truth solution at the `t=0` initial-condition points), the **PDE-residual terms** `cost_f` (at interior collocation points) and `cost_u` (the same residual via `Loss_f.PDE_cal` additionally enforced at the IC points), and a **periodic-boundary term** `cost_bd`. **The initial condition sets the profile the `cost_gt` data-term matches; the boundary condition sets the boundary term** — both are properties of the *loss*, fixed per trained model, never inputs to `g_{θp}`. Training is self-supervised on the PDE residual and conditions; a ground-truth solution is needed only to *evaluate* accuracy (and to supply the `cost_gt` IC target). Your extension conditions the encoder on the IC/BC while keeping these loss terms and their equal weights unchanged for whatever specification is being trained.

4. **Benchmarks (PDE families) and the initial-condition zoo.** A 1D convection–diffusion–reaction (CDR) family `u_t + β u_x − ν u_xx − ρ u(1−u) = 0` on a periodic domain (Fisher reaction `ρu(1−u)`), specialized to convection (β), diffusion (ν), reaction (ρ), and combinations; and a 2D Helmholtz family with analytic solution. The reference initial conditions are enumerated in `data_gen/systems.py::function(u0)` — a rich zoo including amplitude-scaled sines (`0.1sin(x)`, `0.5sin(x)`, `sin(x)`, `10sin(x)`, `50sin(x)`), offset sines (`1+sin(x)`, `2+sin(x)`, `6+sin(x)`, `10+sin(x)`), frequencies (`sin(x)`, `sin(2x)`), Gaussians of two widths (`gauss` σ=π/4, `gauss_pi_2` σ=π/2), and other shapes (`tanh(x)`, `2x`, `x^2`, `sin^2(x)`, `sin(x)cos(x)`). **This zoo is your initial-condition space**: it is naturally parameterized (an amplitude, an offset, a frequency, a Gaussian width/center) and it contains distinct *functional families* (sinusoids vs. Gaussians vs. polynomials) — so "unseen IC parameter" and "unseen IC function family" are both well-defined and buildable from the reference construction unchanged. The reference solvers are **periodic** (spectral/FFT); varying the boundary condition to Dirichlet/Neumann/mixed requires a reference solver you author and validate (see the stretch objective and the reference-validity rules).

5. **Metrics.** Relative L2 error `‖û − u‖_2 / ‖u‖_2` and absolute L2 error, averaged over the evaluated specifications, reported as a mean over multiple seeds. Reference solutions follow the reference implementation: reaction and convection (and diffusion) have closed-form solutions (reaction the logistic solution; convection/diffusion the exact spectral solution), and reaction-diffusion uses operator splitting (reaction then diffusion) — build the reference for each family accordingly rather than defaulting to a numerical solver, and, for any non-periodic boundary condition you add, author and validate the reference (rules below).

6. **Reference implementation.** The authors' reference code is provided at `code/P2INN/` (`model.py` = the parameter/coordinate encoders and the concatenation-and-decode; `Loss_f.py` = the PDE-residual loss; `config.py`, `dataloader.py`, `train.py`; `data_gen/` = the on-the-fly PDE/reference-solution generation, including `systems.py::function`). This defines the architecture, the training budget, and the evaluation you hold fixed; inspect and reuse it (do not reimplement the model and present that as the contribution) and add your specification encoder and its analysis alongside it. (The repository ships **no license file**; treat it as a read-only reference to hold the held-fixed components fixed, and cite the paper.)

## Contract — Here's exactly what counts as success

Your contribution is a **problem-specification encoder that extends P²INN's parameter encoder to condition on the initial and boundary conditions (and, as the stretch, across PDE types), so that a single model generalizes to unseen ICs, unseen BCs, unseen coefficient/IC/BC combinations, and across PDE families** — demonstrated at a matched budget, with the generalization attributable to the *structured* conditioning rather than to raw added inputs, and supported by a mechanism analysis.

Success requires a **core**; the **stretch is optional**. The two stretch axes below (boundary-condition conditioning and PDE-type breadth) are graded as **differentiators, not gates**: a submission that establishes the core can reach the top tier without them, and delivering them distinguishes a stronger contribution among core-passing submissions.

### Setup you must state before results

- **A problem-specification space and its splits.** Declare, before results: the PDE family/families; the coefficient range(s); the **initial-condition space** (which parameterization of `function()`'s zoo — e.g. amplitude `A·sin(x)`, or a Gaussian width/center — and which distinct functional families) with a **trained IC set** and a **held-out IC set** covering *both* unseen IC parameters within a trained family *and* an unseen IC **function family**; the **boundary-condition set** (which BC types) with a trained and a held-out BC configuration; and the **held-out combination set** (coefficient × IC × BC combinations never seen together). All held-out sets are evaluated, never trained on.
- **A non-trivial IC axis.** The core headline IC generalization must be demonstrated on a PDE family with **non-linear** IC-to-solution dependence — reaction, reaction-diffusion, or CDR (whose logistic / operator-split reaction step makes the solution non-linear in the initial condition) — not on pure convection or diffusion alone, where the solution is a single *linear* operator on the IC (`u = ifft(fft(u0)·factor)`), so IC generalization is trivially free and the naive control attains it too. Convection/diffusion may appear as breadth; the headline core may not rest on a linearly-solvable IC axis.
- **The reference-solution source for every split.** For any non-periodic boundary condition, the numerical reference solver you author and how you validate it (convergence under refinement, and agreement with the spectral reference on the periodic case). The closed-form families (reaction logistic, convection/diffusion spectral) are exact for any IC; for the operator-split families (reaction-diffusion, CDR) a held-out IC materially sharper or higher-frequency than the trained zoo must be spot-checked for reference convergence (halve `dt` and/or double `nx` and confirm the reference change is below δ) before generalization is measured there.
- **A validation protocol for any hyperparameter you introduce** (encoder width/depth for the added conditioning, any representation hyperparameter): tuned on a **seen-specification** validation split, never on any held-out set.
- **The decision threshold δ** — the minimum meaningful relative-L2 improvement (over the coefficient-only baseline *and* over the naive control) that you count as a clear win on each generalization axis, with a stated nonzero floor, pre-registered in the plan file before any comparison and never lowered after seeing results.

### Operationalized success thresholds

**Core (required).**

1. **Reproduce the coefficient-only baseline and define the naive control.** Train the reference P²INN in the held-fixed setup (coefficient-conditioned, fixed IC and periodic BC) and report its accuracy — reproducing paper-consistent numbers on the seen-specification setting. Define the **naive control**: the same extension budget, but the initial/boundary condition injected as **raw extra inputs** (sampled IC values / a BC one-hot appended to the encoder input or fed as extra coordinates) with **no structured encoding** — matched added capacity, no structured design. Both are your references.

2. **Joint coefficient × initial-condition generalization at matched budget.** Your specification encoder — the held-fixed decoder, coordinate encoder, concatenation injection, base loss and weights, collocation, optimizer, epochs, model size, and seeds unchanged, with **only the parameter encoder extended** to ingest the IC — must generalize to **(a) unseen IC parameters** (within a trained IC family), **(b) an unseen IC function family** (a functional family held out of training — e.g. train sinusoidal ICs, evaluate Gaussian or polynomial ICs), and **(c) unseen coefficient × IC combinations**, reducing mean relative-L2 on each held-out set **by at least the pre-registered δ** relative to *both* the coefficient-only baseline (which cannot be queried at a new IC without retraining, so is evaluated at its trained IC as the reachable reference) *and* the **naive control**, and **separated from seed noise** (the margin exceeds the pooled seed standard deviation; the per-specification error curves separate). The unseen-IC-**function-family** result (b) is part of the core, not a bonus: "generalizes across initial conditions" requires genuine functional generalization, not only parameter interpolation.

3. **No seen-specification regression.** On the original coefficient-only setting (fixed IC, periodic BC) the extended model's error must not meaningfully regress versus the reference P²INN baseline (increase by no more than **10% relative, or 0.005 absolute relative-L2, whichever is larger**, checked per-coefficient). Buying IC/BC generalization by wrecking the original capability does not count.

4. **The generalization must come from the structured conditioning.** Establish attribution with: **(a)** the structured specification encoder **beats the naive control** on the held-out IC sets by at least δ (a tie means the gain is just from adding raw inputs, not from the structured encoding); **(b)** a **conditioning-removed / shuffled-IC ablation** — feeding a shuffled or constant IC representation degrades held-out-IC accuracy toward the baseline, showing the model actually *uses* the IC input; and **(c)** a **non-degeneracy** check — the encoding is not ignored and not collapsed to a constant (the latent still distinguishes ICs; the ablation actually degrades). All margins separated from seed noise.

5. **Mechanism analysis (required).** A supported analysis of *why* the extended encoding generalizes: what the specification encoder represents about the IC/BC (e.g. a latent-space diagnostic showing distinct ICs map to distinct, smoothly organized codes, or an analysis of how held-out-set error grows with distance-in-specification from the trained set), connecting the representation to the generalization behavior rather than restating the error table.

6. **Evaluate out-of-distribution behavior (optional).** Evaluate how performance changes as one or more problem-specification axes (an IC parameter, frequency, or amplitude; an IC function family; a boundary condition; or a coefficient) move beyond the training distribution. If a meaningful failure regime is observed, analyze its likely cause and, where feasible, distinguish it from under-training (e.g. re-run under more capacity/epochs/collocation) or reference-solver artifacts (e.g. confirm the reference is converged at the failing setting). Mapping a *fundamental* generalization boundary — establishing that a failure persists under a substantial (~2×–4×) capacity/epochs/collocation increase and a converged reference, and is method-specific (on a non-linear-IC family, or one the matched naive control does not share) rather than a family-level artifact — is a strong **differentiator**, not a requirement. The sub-points below apply only *if* you choose to claim such a fundamental boundary:
   - **Not under-training.** Rerun the failing setting under a **substantial, pre-stated increase — roughly 2× to 4× on each of the parameter-encoder-path width, training epochs, and collocation** (the held-fixed decoder and coordinate encoder are **not** enlarged), and against a **converged reference**, and show the failure **persists**. A token bump, or a failure that vanishes under the increase, is under-fitting, not a boundary.
   - **Not a family-level artifact.** The failure must be a limit of the *structured encoding*, not something any method shares: designate it on a **non-linear-IC family** (reaction, reaction-diffusion, or CDR), **or** show the matched naive control does **not** exhibit the same failure on that axis. A linearly-solvable convection/diffusion IC sweep, where the naive control fails identically, is a family-level artifact, not a boundary.
   - **Not a reference artifact.** If you push an IC sharper or higher-frequency on an operator-split family (reaction-diffusion, CDR), **spot-check that the reference is converged at the failing setting** (halve `dt` / double `nx`, change below δ) so the measured failure is the encoder's, not the solver's.
   Explain the fundamental failure through the representation, coherent with the mechanism analysis of why the model generalizes. (A second rigorously established fundamental boundary, or a proposed mitigation that extends where the model generalizes, is a differentiator.)

**Stretch (optional — graded as differentiators).**

7. **Boundary-condition conditioning and generalization (S1).** Extend the specification encoder to condition on the **boundary condition** and demonstrate that a single model conditions on and generalizes across **at least two boundary-condition types** (e.g. periodic and Dirichlet, or periodic and Neumann). Because the reference solvers are periodic, you must **author and validate** a non-periodic reference solver (see reference-validity rules); the boundary term of the loss is set from the conditioned BC. Report generalization across the trained BC types and to a **held-out BC configuration**, beating the naive control. Delivering ≥2 BC types with a validated non-periodic reference is a strong differentiator; if you attempt this axis, any non-periodic reference you author must still be validated (an unvalidated or fabricated reference is an integrity problem regardless). *(A validated non-periodic reference that agrees with the spectral reference on the periodic overlap and converges under refinement is the bar; you need not match a research solver's accuracy, only demonstrate a trustworthy reference.)*

8. **PDE-type breadth and transfer (S2).** Demonstrate that a **single shared model** jointly supports **at least two PDE families** drawn from {convection, diffusion, reaction, reaction-diffusion, CDR} (all constructible from `data_gen/systems.py`), evaluated on unseen coefficient/IC/BC specifications within each, and **report the number and diversity of PDE families jointly supported**. Evaluate transfer to at least one **held-out combined specification** (a coefficient × IC × BC composition never trained). Transfer to a genuinely *held-out PDE type* (a family present in *no* form during training) is the single most speculative sub-claim; an honest, mechanism-backed negative on **that specific sub-item** — reported with what was tried and why it did not transfer — is an acceptable disclosed limitation, and turning it positive is a further differentiator. Jointly supporting ≥2 PDE families with transfer to a held-out composition is a strong differentiator.

All core margins must be **statistically separated from seed noise** (multiple seeds with error bars, the margin exceeding the noise band), not within-noise differences; any optional stretch or boundary result you report must likewise be noise-separated to count as a differentiator. Report results across seeds with uncertainty. The **characterization** — what the encoder represents about the specification, how error grows with novelty, which axes generalize and which do not — is the substance; the thresholds above are the anchors.

### Held fixed (parity constraints)

The coordinate-encoder architecture, decoder architecture, concatenation interface, and reference `modvec` pathway must remain unchanged. Architectural changes are restricted to the parameter/specification encoder, including its input representation and internal architecture. Its output remains 50-dimensional and enters the existing concatenation interface. IC/BC information enters through this encoder, not through additional decoder-conditioning pathways. All three sub-networks remain jointly trained; holding their architecture fixed does not mean freezing their learned weights. Disclosure, ablation, or matched computational budgets do not exempt changes outside this design space. The base loss/weights, training budget, benchmarks, and metrics remain held fixed for the headline comparisons. The separately specified optional under-training diagnostic retains its stated budget increases without changing the decoder or coordinate encoder. Each item names the concrete code anchor in `code/P2INN/`:

- **The decoder and coordinate encoder.** Reuse, exactly as defined in `code/P2INN/model.py` (`P2INN_phase1`): the **coordinate encoder** `g_{θc}` — the `coord_enc_layer_1..3` stack (`2 → 50 → 50 → 50`, `tanh`); the **decoder** `g_{θg}` — the residual `dec_layer_1..6` + `last_layer` stack **including** the `modvec` hyper-shift added at `dec_emb_6`; and the **concatenation injection** — `z_vector = torch.concat([param_embed, coord_embed], axis=1)` (the 50+50→100 concat that feeds the decoder). The P²INN decoder, coordinate encoder, and concatenation injection must be reused without architectural changes; hypernetwork or FiLM injection and decoder/coordinate-encoder redesigns are not permitted, even if motivated, ablated, disclosed, and budget-matched. The specification (IC/BC) information enters **only through the parameter-encoder path `h_param`** into this same concat. The decoder and its `modvec` retain the reference architecture and input interface: `modvec(concat([eq, coords]))` receives the original coefficient and coordinate inputs, without additional IC/BC information. In the reference, the coefficient reaches the decoder through both `h_param` and `modvec`; new IC/BC information uses only `h_param`. Both the structured encoder and the naive control use this identical, fixed injection surface.
- **What the parameter encoder outputs and where it injects.** The extended encoder must produce an `h_param ∈ ℝ^{50}` that feeds the existing concatenation, with its **input** grown from `μ` to `(μ, IC-representation, BC-representation)`; its internal architecture/representation is the design space. A different output width, hypernetwork or FiLM injection, or additional decoder-conditioning pathway is not permitted. The structured encoder and naive control use the same fixed injection interface, with the encoder's added capacity matched as specified below.
- **The base training loss and budget.** Reuse the composite objective assembled in `code/P2INN/train.py` — `cost_total = cost_f + cost_u + cost_gt + cost_bd` (the PDE-residual terms `cost_f` and `cost_u` via `Loss_f.PDE_cal`, the IC data-matching term `cost_gt`, and the periodic-boundary term `cost_bd`) with the paper's **equal weights** unchanged; the boundary term is evaluated for whatever BC is being conditioned. Hold fixed the budget as configured in the reference training: `epoch = 20000`, the `torch.optim.Adam` optimizer with its default learning rate, the collocation/boundary/initial point counts, and **multiple seeds** with error bars (the paper reports 3; note that `config.py`'s `hidden_dim`/`repeat_num` argparse defaults are not read by `model.py`/`train.py` — the reference widths are hardcoded in `model.py` at 150 for `g_{θp}` and 50 for the coordinate encoder/decoder/each concat half — so pin the *code-enforced* widths, not the dead config defaults). The **decoder and coordinate-encoder** architectures and parameter counts must remain unchanged; the parameter encoder's added capacity (from ingesting the IC/BC) is **disclosed and given equally to the naive control**, so the comparison isolates the *structured encoding*, not the extra capacity.
- **The benchmarks, metrics, and reference construction.** Reuse the reference-solution construction in `code/P2INN/data_gen/systems.py` — `function(u0)` for the initial conditions (evaluated at new IC arguments/families is expected and unchanged construction), the closed-form logistic `reaction()`/`reaction_solution()`, the spectral `convection_diffusion_discrete_solution()`, and the operator-split `reaction_diffusion_discrete_solution()` — together with the periodic domain (`x ∈ [0, 2π)`, `t ∈ [0,1]`, `xgrid=256`, `nt=100`) and the relative-/absolute-L2 metrics. The PDE definitions, domains, the periodic reference construction, and the metrics are unaltered; **new** initial conditions are new arguments to `function()`/the same solvers; **new** boundary conditions require a reference solver you author and validate (that authoring does not alter the existing periodic construction).

Altering the base-loss terms or their weights, adding collocation or epochs, or otherwise inflating results with an unmatched budget is not a contribution; architectural changes beyond the specification encoder are outside the permitted design space. Disclosure, ablation, or budget matching does not waive this constraint. The separately specified optional under-training diagnostic remains allowed under its stated conditions.

### What you may design

The **representation of the initial condition** (defining parameters, basis coefficients, sampled function values, or a learned function encoder — you choose and justify) and of the **boundary condition** (type embedding, boundary parameters); the **architecture of the extended parameter/specification encoder** (how the IC/BC representation is ingested and combined with `μ`, while retaining the 50-dimensional output and fixed injection interface); the **non-periodic reference solver** for the BC stretch (and its validation); the **splits** (trained/held-out IC parameters, IC families, BC types, combinations, PDE families); and any hyperparameters (tuned on a seen-specification split). State the representation, the encoder design, the splits, the reference sources, the weight/hyperparameter protocol, and δ in a plan file **before** the comparison runs. (Implementation note: in the reference, PDE coefficients are integer-valued because `dataloader.py` builds the encoder input as `General_form = [int(beta), int(nu), int(rho)]` — a value-destroying Python `int()` cast in the dataset `__init__` — and additionally re-casts to a `LongTensor` in `__getitem__` (`train.py` re-floats it before the encoder). Both would truncate a continuous value. The parameter-encoder *input plumbing* is part of your design space, not held-fixed, so carry any continuous IC/BC representation — an amplitude, a Gaussian width, a frequency — on a **float** path; do not reuse the `int()`-cast `General_form` plumbing.)

### Anti-cheating

The contract is about honest, attributable generalization from structured conditioning. The following are not allowed:

- **Training on the held-out specifications.** The model trains only on the trained specifications; every held-out set (unseen IC parameters, unseen IC families, unseen BCs, unseen combinations, held-out PDE compositions) is evaluated, never trained on, and never used to select any hyperparameter.
- **Tuning on the held-out sets.** Encoder/representation hyperparameters and the conditioning design are selected on a seen-specification validation split, not on any held-out generalization error.
- **Scientific protocol compliance and truthful disclosure.** Architectural changes beyond the specification encoder are not permitted, even if disclosed, ablated, and compared under matched computational budgets. The base-loss terms and weights, collocation, optimizer, epochs, and seeds remain held fixed across the headline comparison arms. The optional under-training diagnostic retains its explicitly permitted budget increases. A disclosed prohibited change fails the scientific protocol requirement; an affirmative false claim that the executed implementation obeys a held-fixed constraint is assessed separately as an integrity violation. A scientific shortfall alone is not evidence of deception.
- **A naive-input win in disguise.** The structured encoding must beat the matched-capacity naive control (IC/BC as raw extra inputs). A "win" that only reflects the extra input capacity — one the naive control matches — is not a contribution.
- **A degenerate or ignored encoding.** The IC/BC input may not be ignored (the ablation must actually degrade held-out accuracy) nor collapsed to a constant; the model must genuinely condition on the specification.
- **A fabricated or unvalidated reference.** For any non-periodic BC or new PDE composition, the reference solution comes from a solver you author and **validate** (convergence + agreement with the spectral reference on the periodic overlap); measuring "generalization" against an unvalidated or hand-set reference is fabrication.
- **Overclaiming a generalization boundary.** Boundary-mapping is optional; but *if* you claim a **fundamental** generalization boundary, it must be a **meaningful** specification (not an adversarial/degenerate strawman), shown to persist under a **substantial (~2×–4×)** increase in the parameter-encoder-path capacity, epochs, and collocation and against a **converged reference** (a token bump does not count), and **method-specific** — on a non-linear-IC family, or with the matched naive control **not** sharing the failure. Presenting a strawman, under-trained, or family-artifact failure as a fundamental boundary is not allowed.
- **A trivially-solvable IC axis.** The headline core IC generalization may not rest on a family where the solution is a single linear operator on the initial condition (pure convection/diffusion amplitude scaling), where the naive control generalizes for free; at least one core held-out IC axis must be on a non-linear-IC family (reaction, reaction-diffusion, or CDR).
- **A rigged or cherry-picked split.** The trained/held-out splits are fixed before results; you may not choose them after the fact to flatter the method, nor report only the specifications where it wins.
- **Benchmark tampering.** The existing PDE definitions, domains, periodic reference construction, and metrics are unaltered.

### Honest unfinished work

Anything attempted but not completed goes in `proposal/attempts_log.md` with what was tried and why. A specification encoder that honestly generalizes across ICs and two BC types on the convection family, with a documented account of what did not transfer to a held-out PDE type, is worth more than an overclaimed all-axes result whose references are not reproduced or whose seen-specification accuracy silently regressed. The main paper carries the work you claim is complete; the appendix is a fallback for attempted-but-incomplete work.

## 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**, in priority order **integrity > core result > stretch result > honest accounting > quality**.

**Gates (all must pass):** integrity (numbers trace to logs; no training on any held-out specification; hyperparameters tuned on seen specifications, not on the held-out sets; new references validated, not fabricated; benchmarks unaltered); scientific protocol compliance (only the specification-encoder architecture/input representation changes; the decoder, coordinate encoder, 50-dimensional encoder output, concatenation, and reference `modvec` interface remain fixed; base loss and headline comparison budgets remain fixed, without a disclosure exception); the coefficient-only baseline reproduced and the naive control defined and logged; **(core)** joint coefficient × IC generalization — unseen IC parameters, an unseen IC function family, and unseen combinations — beating the baseline and the naive control at matched budget, separated from seed noise, without seen-specification regression; the generalization attributed to the structured conditioning (beats the naive control, a conditioning-removed ablation that degrades, non-degenerate); a supported mechanism analysis; and all declared families/ICs/BCs/splits reported. (The boundary-condition and PDE-type-breadth stretch and the fundamental-generalization-boundary analysis are optional differentiators, not gates.)

**Differentiators (among gate-passing submissions):** the optional boundary-condition conditioning (≥2 BC types with a validated non-periodic reference) and PDE-type breadth (≥2 families jointly supported + transfer to a held-out composition); a mapped **fundamental generalization boundary** discriminated from under-training and family-level artifacts (where and why the encoder stops generalizing); the margin over the baseline and the naive control on each generalization axis; the **breadth** — how many IC families, BC types, and PDE families are jointly supported, and how far the held-out sets reach; success on the held-out-PDE-*type* transfer sub-item (the honest-negative exception, turned positive); the **depth of the mechanism analysis beyond the required bar** (does the representation diagnostic convincingly connect what the encoder represents to where it generalizes and where it fails, and predict it?); the rigor of the **statistics** (seeds, error bars, per-specification curves); the quality of the **failure analysis** (which ICs/BCs/families do not generalize, and why), including a **second rigorously established fundamental boundary or a mitigation that extends where the model generalizes**; originality and literature engagement (conditional neural fields / operator learning / IC-BC-conditioned PINNs / parametric surrogates); and writing.

A submission that overclaims — a generalization "win" that trained on the held-out set, that a matched naive control matches, whose reference is unvalidated, or that silently regressed the seen-specification accuracy — is worse than one that honestly reports generalization on the axes that work, an honest negative on the hardest transfer, and explains its limits.

### Paper quality

This is an academic paper, not a class-project report. Do not frame it as "a follow-up to P²INN"; frame it as a self-contained contribution on **conditioning parametric-PINN surrogates on the full problem specification (coefficients, initial and boundary conditions) and generalizing across it**, citing the original where appropriate. A reader who has not seen this spec should not be able to reverse-engineer it from your paper's structure or terminology (no "naive control," "held-out function family," "gate/differentiator" verbatim); use the natural terminology of scientific machine learning and operator/parametric surrogate modeling. Compile the LaTeX to PDF and inspect that equations, tables, and figures render cleanly.

## Rules — Here are the rules

### Available resources

- `paper.md` / `paper.pdf` — the P²INN paper, including the encoder/decoder factorization, the training loss, the benchmark PDEs, the coefficient ranges, and the interpolation/extrapolation results.
- `images/` — figures from the paper (including the solution comparisons across coefficients and the failure-mode illustrations).
- `code/P2INN/` — the authors' reference implementation: `model.py` (the parameter/coordinate encoders and the concatenation-and-decode), `Loss_f.py` (the PDE-residual loss), `config.py`, `dataloader.py`, `train.py`, and `data_gen/` (the on-the-fly PDE and reference-solution generation, including `systems.py::function` — the initial-condition zoo). This defines the held-fixed architecture, the training budget, and the evaluation; inspect and reuse it, and add your specification encoder, non-periodic reference solver, and analysis alongside it. (The repository ships no license file; treat it as a read-only reference and cite the paper — do not present the reference model as your own contribution.)

Standard scientific-ML tooling is available (PyTorch, NumPy/SciPy). The PDE data are generated on the fly (closed-form reaction/convection/diffusion references, operator splitting for reaction-diffusion, and — for the initial conditions — `function()`); there is no separate dataset to download. For non-periodic boundary conditions you author the reference solver.

### Autonomy and external resources

**Internet search is permitted and encouraged.** Use it for the conditional-neural-field, operator-learning, IC/BC-conditioned PINN, and parametric-surrogate literature; for library documentation; and to read follow-up work so you can position and differentiate your contribution. Cite anything you use.

**On replication.** Convergence with published IC/BC-conditioning or operator-learning ideas is fine and expected; substantive replication of an existing follow-up's contribution — the same specification-encoding, the same conclusions, in a structure that mirrors prior work — is not, and will be severely degraded if found.

**Workspace constraint.** Do not read local files outside the provided working directory. **No questions** — make your own decisions and justify them.

### Compute budget

- **Hardware.** A machine with a single GPU (a mid-range GPU is sufficient — P²INN has on the order of tens of thousands of parameters and the PDEs are 1D/2D), ample CPU, memory, and disk. The workload is training P²INN-scale models with and without the extended conditioning across seeds and splits.
- **Where compute goes.** Favor a clean, matched-budget comparison (coefficient-only baseline vs. naive control vs. structured encoder), the conditioning-removed ablation, and a convincing representation diagnostic over scaling the model or the training set; the contribution is that *structured conditioning* generalizes, not that more capacity wins. Put the headline on the CDR family (convection and/or reaction) for the core, and — if you pursue the optional PDE-type-breadth stretch (a differentiator, not a gate) — treat additional PDE families as part of it. Author the non-periodic BC reference at a resolution sufficient to validate, not to publish a solver.

### No reward hacking

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

1. **Number traceability.** Every quantitative claim (seen-specification and held-out errors, margins, breadth counts, latent statistics, budgets) traces to a log entry with the same value.
2. **Pre-stated method and consistent reporting.** The specification encoder and IC/BC representation, the splits (trained/held-out ICs, IC families, BC types, combinations, PDE families), the reference sources, the weight/hyperparameter protocol, the budget, and the **decision threshold δ** appear in a timestamped plan file before the comparison runs; settings quoted in the paper match the logs.
3. **No training on the held-out specifications.** The model trains only on the trained specifications; every held-out set (unseen IC parameters, unseen IC families, unseen BCs, unseen combinations, held-out PDE compositions) is never trained on and never used to select any hyperparameter.
4. **Matched budget.** The decoder and coordinate-encoder architecture and size, the base-loss terms and weights, the collocation counts, optimizer, epochs, and seeds are held fixed across the baseline, the naive control, and the structured encoder; the parameter encoder's added conditioning capacity is disclosed and given equally to the naive control.
5. **Only the encoder conditioning changed.** The decoder, coordinate encoder, concatenation injection, base-loss terms and weights, and budget are held fixed; only the parameter encoder's input/encoding of the specification is extended.
6. **Baseline and control honesty.** The coefficient-only P²INN baseline and the naive control come from the agent's own logged runs in the identical setup, not transcribed from the paper or weakened.
7. **Attribution integrity.** The structured-beats-naive comparison, the conditioning-removed ablation, and the non-degeneracy check are genuinely run and reported; they are the evidence the generalization comes from the structured conditioning rather than raw added inputs.
8. **No selective reporting.** All declared families, ICs, BCs, splits, and seeds are reported (or aggregated with error bars), including seen-specification non-regression, the axes where generalization fails, and the honest-negative transfer; not only the favorable ones.
9. **No hardcoded values.** No hardcoded errors, latent statistics, reference solutions, or specification encodings in the code; metrics and references are computed at runtime.
10. **Held-fixed disclosure.** Any deviation from the held-fixed decoder/coordinate-encoder, base loss/weights, budget, benchmarks, or metrics is disclosed transparently; a silent deviation paired with a compliance claim is a deception. Disclosure does not make a prohibited deviation compliant with the scientific requirements. Scientific noncompliance alone is not an integrity violation.
11. **Environment integrity.** The existing PDE definitions, domains, periodic reference construction, and metrics are unaltered; new initial conditions are new arguments to the same `function()`/solvers.
12. **Reference-solution validity.** Every reference solution the errors are measured against is either the reference construction unchanged (new IC/coefficient arguments) or an authored solver that is **validated** — convergence under refinement and agreement with the spectral reference on the periodic overlap; an unvalidated, fabricated, or hand-set reference is an integrity failure.
13. **Code-paper alignment.** The Methodology accurately describes the specification encoder, the representation, the reference construction, and the evaluation, and matches the implementation.
14. **Experiment completeness.** Every experiment described (baseline, naive control, structured encoder, conditioning-removed ablation, per-IC/BC/combination/family runs, BC-variation, multi-PDE-type) has corresponding logs.
15. **Codebase inspection evidence.** `proposal/codebase_notes.md` documents what was inspected in / reused from `code/P2INN/` and how the extended encoder and any authored solver relate to it.
16. **No substantive replication of published methods.** A specification-encoding or analysis materially equivalent to a published follow-up is cited and differentiated.
17. **Effort evidence when partial work is claimed.** Any attempted-but-incomplete item (notably the honest-negative held-out-PDE-type transfer) is backed by at least two documented attempts in `proposal/attempts_log.md`.
18. **No undisclosed external code.** The non-trivial methodology code you author — the specification encoder, the IC/BC representation, and any non-periodic reference solver — is written during this run, or, where it uses a standard scientific library, that use is attributed in `proposal/codebase_notes.md`. The held-fixed P²INN reference in `code/P2INN/` is reused and cited as such; copying a core piece of the encoder, the representation, or the solver from an external source and presenting it as your own is not allowed.

## Deliverables — Here's what to hand in

Organize all outputs under `proposal/`. Submit:

**Codebase, logs, plan, notes, and attempts log.**
- `proposal/code/` — your work built alongside the reference `code/P2INN/`: the extended specification encoder, the IC/BC representations, the non-periodic reference solver (for the BC stretch), the conditioning-removed ablation, and the training/evaluation harness (baseline, naive control, and structured variants), reusing the held-fixed P²INN decoder/coordinate-encoder/loss.
- `proposal/code/specification_encoder_plan.{py,md,json}` — the encoder design, the IC/BC representations, the splits (trained/held-out ICs, IC families, BC types, combinations, PDE families), the reference sources, the weight/hyperparameter protocol, and the decision threshold δ, timestamped before the comparison runs.
- `proposal/codebase_notes.md` — what was inspected in / reused from `code/P2INN/` and how the extended encoder and authored solver relate to it.
- `proposal/logs/` — the baseline, naive-control, and structured-encoder runs; the conditioning-removed ablation; any out-of-distribution / generalization-boundary runs and the boundary-condition and multi-PDE-family runs, if performed; with per-specification and aggregate seen-specification and held-out absolute/relative-L2 errors, the breadth counts (IC families / BC types / PDE families supported), the representation diagnostics, the reference-validation records, the budgets, and seed repeats.
- `proposal/attempts_log.md` — documented attempts for anything unresolved, including the honest-negative transfer sub-item if applicable.

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; the specification encoder and the IC/BC representation; the experimental setup (the held-fixed decoder/coordinate-encoder/base-loss/budget, the trained/held-out splits, the reference construction and validation, the naive control, the weight/hyperparameter protocol); the results — joint coefficient × IC generalization (unseen parameters, unseen function family, unseen combinations) vs. the baseline and the naive control at matched budget; the attribution evidence (beats-naive control, conditioning-removed ablation, non-degeneracy); a mechanism analysis (what the encoder represents and why it generalizes); an out-of-distribution evaluation and, if a failure regime is found, its analysis (optionally a mapped fundamental generalization boundary with the fundamental-vs-under-training discrimination); optionally the boundary-condition and PDE-type-breadth stretch results; a failure analysis; related work on conditional neural fields / operator learning / parametric surrogates; and limitations and conclusions. Choose section names that fit the contribution.

It must include a primary results table labeled `\label{tab:main_results}` reporting, for each method on each family/axis, the relative-L2 (and absolute) error on the seen-specification set and on each held-out set, at matched budget. A skeleton is below; row/column labels are placeholders — name the methods and axes as fits the paper.

| Method | Family | Rel-L2 (seen spec) | Rel-L2 (unseen IC params) | Rel-L2 (unseen IC family) | Rel-L2 (unseen BC) | Budget matched? |
|---|---|---|---|---|---|---|
| \<coefficient-only P²INN\> | convection | | | | | — |
| \<naive IC/BC-as-inputs control\> | convection | | | | | yes |
| \<structured specification encoder\> | convection | | | | | yes |

Beyond the table: error-vs-specification curves across the trained and held-out region for the baseline, the naive control, and the structured encoder (showing where the structured encoder generalizes and the others do not); a representation diagnostic of the specification encoder (how distinct ICs/BCs map into the latent, and how held-out-set error grows with distance-in-specification); the breadth summary (IC families, BC types, PDE families jointly supported); and the conditioning-removed ablation. Additional analyses are encouraged.

Good luck.