{"claim":{"id":"bb51a653-155c-46d0-9891-a49645e5b62e","submission_id":"a44e897b-fd21-4297-a9ee-a392d2e494dc","submission_revision_id":"a0b12ed0-1b59-47fb-9e4a-f4196a048854","builder":"builder-01","status":"active","claimed_at":"2026-10-15T15:07:00.588296Z","delivered_at":null,"ended_at":null,"delivery_note":null,"end_reason":null},"task":{"submission_id":"a44e897b-fd21-4297-a9ee-a392d2e494dc","submission_revision_id":"a0b12ed0-1b59-47fb-9e4a-f4196a048854","revision_version":2,"submission_status":"under_review","submitted_at":"2026-08-17T00:38:41.978833Z","submitter_name":"Haoxuan Chen","submitter_email":"haoxuan@alumni.caltech.edu","task":{"status":"submitted","version":2,"extra_fields":{},"submitted_at":"2026-08-17T00:38:41.978833+00:00","industry_domain":"Numerical Analysis and Scientific Computing","task_short_name":"Modified High-Order Box Scheme for advection PDE in Scientific Computing","operating_system":"Linux","task_description":"You are working on a Linux coding task about high-order compact implicit\nfinite-difference schemes for the periodic advection equation.\n\n**Task directory:** `base`\n\n**Visible input files:**\n- Problem specification: `base/input/problem_spec.md`\n- Python runtime manifest: `base/input/runtime_env/pyproject.toml`\n- Python lockfile: `base/input/runtime_env/uv.lock`\n- Canonical Python wrapper: `base/software/python.sh`\n\n**Recommended workflow:**\n1. Change into `base`.\n2. Read `base/input/problem_spec.md` in full before coding.\n3. Use `\"base/software/python.sh\" your_script.py` or\n   `\"base/software/python.sh\" -c \"...\"` to run Python with the staged\n   NumPy/SciPy environment.\n4. Implement your solver and save it to `base/output/box_solver.py`, exposing\n   `solve(h, k, T=1.0)`.\n5. Run the solver and write every required artifact under `base/output`.\n\n**Required outputs under `base/output`:** `box_solver.py`,\n`reference_arrays.npz`, `results.json`.\n\n**Objective:** Fully characterize and implement a compact implicit **modified\nbox scheme** for the inhomogeneous advection PDE `u_t + a·u_x = f` on a periodic\ndomain `[0, 2π]`: set up its linear system, **compute its amplification factor**\nto characterize stability, determine its **order of accuracy** in time and space\nfrom numerical experiments, and validate against a manufactured solution. `a = 1`;\nexact `u_e = (1+t)·sin(x−t)`, `f = sin(x−t)`, `u(x,0)=sin(x)`; errors at `T = 1`\nin the discrete `L²` norm. The scheme is given as a stencil; its qualitative\nbehaviour is *not* — derive the periodic linear system, the amplification factor,\nand the two orders yourself.\n\n**Instructions & Rules:**\n1. Implement in `base/output/box_solver.py` using **Python + NumPy + SciPy\n   only** — no PDE/FDM library; derive and build the periodic operators and the\n   banded solve yourself.\n2. **(A) Linear system:** cast one step as a periodic banded solve (mind the\n   `+2`-offset wrap-around).\n3. **(B) Amplification factor (Tier 3):** from the von Neumann ansatz, compute\n   `g(θ; λ)` in closed form and report it numerically — the complex `g(θ)` at\n   `a=1, λ=1` **and at the largest `λ` you test** — together with\n   `max_θ||g|−1|` for each `λ` over a range spanning `≤1` to `≥8`. Read the\n   stability off those numbers. Graded purely on the reported arrays; no written\n   proof is required. Every reported deviation is independently recomputed.\n4. **(C) Order (Tier 1 + Tier 2, core):** determine the space and time orders\n   numerically. Run the *specified* fixed-`k` study (`k=2⁻⁸`, `h=2π·2⁻ᵖ`,\n   `p=2..8`). Then — because the error superposes a time term and a space term,\n   and one refinement path lets one mask the other — **design two further studies\n   that each isolate one term**, recovering the order in `k` and the order in `h`.\n5. **(D) Artifact (Tier 3):** solve at `h=2π·2⁻⁸`, `k=2⁻¹⁴` (M=256) and save the\n   grid, numerical solution, exact solution, and pointwise error at `T=1`.\n6. `box_solver.py` must be importable without side effects and expose\n   `solve(h, k, T=1.0) -> (x, u)` working for **any** valid `(h, k)`: the grader\n   calls it on meshes of its own choosing as well as on yours.\n7. Write `reference_arrays.npz` and a consistent `results.json` per the schema in\n   the specification; keep every saved value truthful — the grader recomputes the\n   exact solution, the amplification factor and its deviation at every `λ`, and\n   all convergence orders, and it re-executes your solver.\n8. Do not modify files outside `base/output`.","software_licensing":"Free/Open Source","evaluation_criteria":null,"verification_method":"An automated grader (`evaluation/grade.py`, provided) applies **strict, objective**\nrules. It knows the scheme, the exact solution and the analytic amplification\nfactor; it recomputes the exact solution, every convergence order, and the\nstability deviation for *every* submitted `λ`; and it **re-executes the submitted\nsolver in an isolated subprocess**, including on meshes of its own choosing.\nBecause the stencil is fully specified, the grader also carries an independent\nimplementation of the scheme (a Fourier time stepper) and compares against it —\nso a wrong periodic assembly, a stubbed solver, or fabricated metrics all fail.\n\n**Scoring**\n- `1.0` — Tier 1 + Tier 2 + provenance + Tier 3 (stability + artifact) all pass.\n- `0.5` — Tier 1 + Tier 2 and all provenance checks pass, Tier 3 fails.\n- `0.0` — required files missing (including `box_solver.py`), array or JSON\n  schema violations, `results.json` inconsistent with the arrays, a `*_eoc`\n  inconsistent with its errors, wrong specified mesh sequence, instability, a\n  disallowed dependency, a solver that does not implement the specified scheme,\n  a solver that cannot reproduce its own submitted numbers, a fabricated\n  stability deviation, or Tier 1 / Tier 2 fail.\n\n**Objective thresholds** (exact reference magnitudes live only in the uploaded\n`grade.py` / `EVALUATION.md`, which are evaluation dependencies — not part of the agent's task input):\n- Tier 1: each naive error finite, positive and within ±25 % of the gold reference; coarse-regime orders (`p=3,4,5`) in `[3.7, 4.25]`. The band is legitimate because the stencil is fully specified — there is exactly one correct answer, and `grade.py --self-test` reproduces the band from the grader's own independent implementation.\n- Tier 2: the naive study stalls at fine `h` (two finest orders < 1, error floors within ±25 % of the reference floor); the agent's **k-isolation** uses a fixed `h` with `h² ≤ min(k)/4` and recovers order ∈ [1.85, 2.15]; the **h-isolation** uses a fixed `k` with `k ≤ min(h)²/4` and recovers order ∈ [3.8, 4.25].\n- Provenance: `box_solver.py` present, importable, exposing `solve(h, k, T=1.0)`,\n  importing nothing outside stdlib + NumPy + SciPy; its solution matching the\n  grader's own solution of the specified scheme on three grader-selected meshes\n  (including a non-dyadic one) to `1e-9`; and regenerating the submitted study\n  errors to `1e-6` relative. The 256-point artifact is re-run too.\n- Tier 3 (stability): the reported `g(θ)` matches the **true** amplification\n  factor within `1e-6` at `λ = 1` *and* at `λ = max(λ tested)`; `|g|=1` within\n  `1e-8`; and every `max_θ||g|−1|` is below `1e-8` *and* within `1e-12` of the\n  grader's own recomputation. Asserting `|g|=1` without the correct `g(θ)` fails.\n- Tier 3 (artifact): `x_finest` exactly `m·2π·2⁻⁸`, `m = 0..255`;\n  `u_exact_finest` equal to the analytic solution; `error_finest ==\n  u_finest − u_exact_finest`; recomputed max-norm error below the gold\n  tolerance; and `u_finest` reproduced pointwise by re-running the solver\n  (`rtol=1e-10`, `atol=1e-12`).\n- Consistency: `results.json` must agree with `reference_arrays.npz` on all three\n  study tables (`p`, mesh, error, `eoc`), both order claims, the stability\n  lambdas and deviations, and the scalar metadata.\n\n`grade.py --self-test` is included as reproducible evidence that the grader's own\nimplementation of the scheme reproduces the reference table it grades against.\n\nThe concrete reference error magnitudes are kept out of this field and placed\nonly in the uploaded evaluation dependencies, so no answer-key information\nreaches the solving agent even if this text is surfaced to it.","software_and_version":"Python >=3.11,<3.14, NumPy 2.4.6, SciPy 1.17.1","specific_requirements":null,"expected_completion_time":null},"files":[{"file_id":"1dbb8f09-5a0c-4b1c-bbec-15a75d25e4c9","filename":"problem_spec.md","category":"input_materials","content_type":"text/markdown","size_bytes":11984},{"file_id":"52987f29-8678-4cd5-95df-94a409dac0a1","filename":"python.sh","category":"input_materials","content_type":"application/x-sh","size_bytes":1218},{"file_id":"9d9009fd-dcb3-4fb9-abde-86a4a6074585","filename":"pyproject.toml","category":"input_materials","content_type":"application/octet-stream","size_bytes":243},{"file_id":"577dbed2-3b3e-4b18-a28f-62df26afcb92","filename":"uv.lock","category":"input_materials","content_type":"application/octet-stream","size_bytes":29641},{"file_id":"f5e8db19-8f27-42c2-a557-518d7b9d491e","filename":"box_solver.py","category":"reference_output","content_type":"text/x-python-script","size_bytes":13362},{"file_id":"05ce24f0-5a6f-47a4-a9aa-64f1e0bf9e55","filename":"reference_arrays.npz","category":"reference_output","content_type":"application/octet-stream","size_bytes":25748},{"file_id":"14261d99-4b75-4fa6-ac8e-722e77bc6b05","filename":"results.json","category":"reference_output","content_type":"application/json","size_bytes":4460},{"file_id":"549af2f7-23c7-4189-a07e-3f955cddbc44","filename":"EVALUATION.md","category":"reference_output","content_type":"text/markdown","size_bytes":12779},{"file_id":"aca5ef94-1f99-4b54-8453-343847d4e18b","filename":"grade.py","category":"reference_output","content_type":"text/x-python-script","size_bytes":57530}],"deep_review":{"overall_verdict":"Accept","review_text":"**Overall Verdict:** Accept — The task is complete, objectively verifiable, and end-to-end reachable; only a routine runtime-wrapper path correction is advisable.\n\n**Completeness Check:**\n- Instruction: Complete — The PDE, stencil, manufactured solution, studies, solver interface, output schemas, constraints, and completion criteria are fully specified.\n- Inputs: Complete — The specification and pinned runtime manifests are readable and sufficient; solver-visible inputs are clearly separated from evaluator-only references.\n- Toolchain: Complete — Python 3.11–3.13 with pinned open-source NumPy and SciPy dependencies provides a reproducible Linux toolchain, although the wrapper’s relative project path does not match the declared runtime-input location.\n- Reference output: Complete — The solver source, 26-array NPZ artifact, and JSON sidecar are structurally consistent. Independent numeric checks reproduced the stated orders, amplification factors, stability behavior, and artifact accuracy.\n- Rubric: Complete — The evaluator defines objective tiered scoring, schema and provenance checks, independent scheme fidelity tests, convergence thresholds, stability validation, artifact regeneration, and explicit failure behavior.\n\n**File and Task Reachability:**\nAttachment classification: `reachable`. All nine manifested attachments were inspected: `problem_spec.md`, `python.sh`, `pyproject.toml`, `uv.lock`, `box_solver.py`, `reference_arrays.npz`, `results.json`, `EVALUATION.md`, and `grade.py`. Their byte counts match the manifest. Text files are readable ASCII or UTF-8; the NPZ is an unencrypted single-part archive containing 26 flat, non-object NumPy arrays with expected scalar, 5-, 7-, and 256-element shapes. Only the first entries of the three EOC arrays contain intended NaNs. No attachment content remains unreviewed.\n\nTask classification: `reachable`. A contributor can use the supplied specification and pinned open-source dependencies on one ordinary Linux machine, produce the three required outputs, and be evaluated through independent solver fidelity, regeneration, convergence, stability, and artifact checks. Reference answers and evaluator-selected meshes are confined to reference/evaluator attachments rather than the declared solver-visible inputs. Submitted executables were inspected statically and not run; independent non-executing calculations validated the principal numerical contracts. The wrapper path issue has a deterministic local correction and does not block the available manifest-based toolchain.\n\nLicense keys, accounts, tokens, and other credentials are not required from the contributor. Confidential, proprietary, or internal material may be evaluated as submitted evidence without requiring additional disclosure.\n\n**Special Screening:**\nNone. There is no affirmative evidence of AI-fabricated core material, a public benchmark with a retrievable protected answer, or a deliberately injected defect fixture. Public identifiability could not be independently searched under the permitted review boundary.\n\n**Recommended Changes:**\nThe numerical specification, reference artifacts, and evaluator are coherent and unusually thorough; no material contributor revision is required. As routine cleanup, update `python.sh` to resolve the runtime project at the declared input-runtime directory, or stage a matching directory alias, and clarify that temporary virtual-environment creation is permitted despite the output-only task-file rule.","reviewed_at":"2026-08-17T00:45:34.377949Z"},"claim":{"id":"bb51a653-155c-46d0-9891-a49645e5b62e","submission_id":"a44e897b-fd21-4297-a9ee-a392d2e494dc","submission_revision_id":"a0b12ed0-1b59-47fb-9e4a-f4196a048854","builder":"builder-01","status":"active","claimed_at":"2026-10-15T15:07:00.588296Z","delivered_at":null,"ended_at":null,"delivery_note":null,"end_reason":null}},"revision_is_current":true}