[
  {
    "id": "case_000",
    "options": {
      "A": "Goal: Write a MATH-500 near-side fingerprint paper for NeurIPS Findings, the Datasets and Benchmarks track, or a workshop.\n\nPlan: Use the collected Qwen3-4B-Instruct MATH-500 run of 30 clusters and 3 seeds as the only headline cell. Report Game24 as a Stage 0 parser audit and a cap-binding incident note. Send this packet to the reviewer. Place a second model family, a Game24 run on a larger Instruct model, and the frontier AIME four-arm table in later work, with the spent GPU cost of 55 dollars and a 30 to 50 dollar API block treated as the proposal envelope.",
      "B": "Goal: Write a NeurIPS main fingerprint paper with at least two model-family by task cells.\n\nPlan: Collect the running Game24 R2v7 seeds and run the joint cluster-bootstrap, mixed-effects, and SMD analysis with MATH-500. Add Qwen3-7B-Instruct on MATH-500 with the eight core arms. If Game24 on Qwen3-4B-Instruct stays cap-bound, run Game24 on Qwen3-7B-Instruct. Run the Stage 5 AIME four-arm table on a frontier API with the proposal API budget. Treat the 800 to 1200 GPU-hour figure as a forecast."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_001",
    "options": {
      "A": "Goal: Fit the original five-parameter resolution law after a large-deformation model and a new force measurement are in place.\n\nPlan: Build a five-parameter corotational large-deformation cloth model that keeps the same coefficients as the current linear model. Collect a new synchronized known-force or boundary-reaction measurement so that density, tension, and bending can be recovered separately. After this model is fitted to real fast shaking cloth motion and the five coefficients are identifiable, estimate the original resolution formulas on that model and test them on unseen mesh sizes and time steps.",
      "B": "Goal: Find how the effective parameters of an existing cloth simulator change with mesh size and time step.\n\nPlan: Use an existing written cloth simulator as the dynamics engine, and use Clothilde if that is the simulator already in the workspace. At several mesh sizes and internal time steps, identify the simulator parameters that match real cloth marker motion. Fit a resolution law that predicts those effective parameters from mesh size and time step. Test the predicted parameters on mesh sizes and time steps that were not used in the fit, and compare them with parameters identified independently at those settings."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_002",
    "options": {
      "A": "Goal: Find the best native effective parameters on a 3 by 3 grid of spatial and time resolutions and then measure how those parameters change with resolution.\n\nPlan: Run meshes 11 by 15, 15 by 21, and 21 by 29 with internal substeps 4, 8, and 16. At each cell, fit the seven Clothilde parameters on the G0 calibration windows under default thickness and under a fixed physical collision radius. Fit a log-linear resolution law on the five cross cells, and hold out the four corner cells for a later prediction check. Report Transferred, Gaussian-process, and same-budget Oracle marker errors on the same cells as a check that simulated error stays near those baselines.",
      "B": "Goal: Close density, optimizer, and contact diagnostics and then run the 3 by 3 resolution matrix under a rule that the RG prediction beats the Transferred baseline.\n\nPlan: Collect a cotton density scale contract and a test of whether adding that density residual recovers all seven native parameters. Run a matched seed-injection factorial with CMA-ES and differential evolution, and an objective ruggedness profile around the existing starts. Keep the agreement rule that each optimizer has at least 3 of 4 starts within 1 mm of the best loss. Measure default thickness and fixed physical collision radius on all nine cells. Start the 3 by 3 Oracle matrix after those tests pass, and count the RG prediction as a pass when held-out error is lower than the Transferred baseline on both contact treatments."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_003",
    "options": {
      "A": "Goal: Start the 3 by 3 resolution matrix after RG predictions beat the Transferred baseline on both contact treatments.\n\nPlan: Compare the collected contact-radius results with the scientific admission rule for R11. Require RG trajectory error to be below Transferred error on every blind cell for default thickness and for fixed physical radius. Require a pooled paired 95 percent lower bound above zero, and a contact treatment difference no larger than 25 percent of the smaller gain. After this admission passes, run the 3 by 3 Oracle matrix on the five cross cells and then on the four corners, and use RG error below Transferred error as the primary comparison.",
      "B": "Goal: Start the 3 by 3 resolution matrix and measure how effective parameters change with space and time resolution.\n\nPlan: Run the 3 by 3 matrix on the five cross cells under default thickness and under fixed physical radius, with CMA-ES and differential evolution, four independent starts, and 4000 evaluations each. Fit a log-linear resolution law and a matched Matern Gaussian process on those five cells. Write the four corner parameter predictions and their hash, then run independent optimizations at the same evaluation budget on the four corner cells. Report RG, Transferred, Gaussian process, and Oracle held-out trajectory errors on each cell."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_004",
    "options": {
      "A": "Goal: Obtain the identified effective-parameter curves versus scale from independent global searches on one host after a same-host objective check.\n\nPlan: Stop the compute node D R21C run and keep its 20 finished chains only as a cross-host diagnostic panel. Replay the sealed identification objective in isolated processes on compute node E and record the endpoint differences between compute node D and compute node E. Then start a new 124-chain R21C search on compute node E from the already declared starts and seeds. Do not copy, resume, or join the compute node D optimizer traces, checkpoints, or best points into that search.",
      "B": "Goal: Obtain the identified effective-parameter curves versus scale from independent global searches on the host that already produced the objective scores.\n\nPlan: Continue the R21C 124-chain independent global search on compute node D and keep the 20 finished chains and the in-flight traces in that run. After every admitted scale has a finished identification on compute node D, run the R21D interval confirmation on the same host. Do not start the remaining identifications on another host, because R20C measured a difference of up to 0.43 mm for the same parameter vector on two hosts."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_005",
    "options": {
      "A": "Goal: Calibrate a larger differential-evolution and CMA-ES search on the fine widened-box cell, then identify effective parameters on the admitted scales with that protocol.\n\nPlan: Re-evaluate the narrow-box best point of the fine 15 by 21 cell on the 12-window widened-box objective in a fresh process. Then run two batches of new Sobol starts, with 16 differential-evolution chains and 16 CMA-ES chains in each batch and 8000 evaluations on every chain. Search the six positive parameters in the log of their raw physical values. Use the hit rate of the known deep basin to set how many chains each later scale will run so that the chance of missing that class of basin stays at most 5 percent. Then run that same differential-evolution and CMA-ES protocol independently on every spatial and time scale that already passed admission.",
      "B": "Goal: Compare two global search methods on the same anchor cells, then identify effective parameters on the admitted scales with one of those methods.\n\nPlan: On the fine 15 by 21 cell and the coarse 4 by 5 cell, run two methods on the same objective and box. The first method uses new Sobol starts with differential evolution and CMA-ES. The second method uses a coarse-to-fine grid to find distinct basins, keeps the lowest K basins, and refines each basin with bounded Nelder-Mead. Sample each parameter uniformly in its original physical quantity, or as the log of that quantity divided by a stated reference that has the same unit. Repeat each method twice at each cell, and record the lowest objective value, the evaluation count, and the core-hours. Then run the method chosen from this comparison independently on every spatial and time scale that already passed admission."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_006",
    "options": {
      "A": "Goal: Select a search method for later scale-by-scale identification by comparing a new grid search with the current optimizer on the fine and coarse cells.\n\nPlan: On the fine cell 15x21_s8 boundary_12 and the coarse cell 4x5_s8 boundary_12, complete the current Sobol-start differential evolution and CMA-ES batches, and run a pairwise grid method in the dimensionless log-ratio coordinates. Split the six parameters into three pairs, delta with alpha, kappa with kappa_bnd, and stretch with shear, and start four joint contexts. For two sweeps, hold four parameters fixed while a two-dimensional coarse-to-fine grid updates one pair, cycling through the three pairs in a declared order, with a 3 by 3 box grid and a 5 by 5 local grid around the two lowest roots in each pair. After the sweeps, polish the top four survivors with bounded Nelder-Mead at 4000 evaluations. Run this schedule in two pair orders on both cells, and run a third pair order on both cells. After these completed runs, take the lowest verified objective as the target. A method is eligible if each completed schedule reaches that target plus 0.1 mm. Then record evaluations, core hours, and wall time, and apply the selected method at every remaining admitted scale.",
      "B": "Goal: Select a search method for later scale-by-scale identification by comparing a new grid search with the current optimizer on the fine and coarse cells.\n\nPlan: On the fine cell 15x21_s8 boundary_12 and the coarse cell 4x5_s8 boundary_12, complete the current Sobol-start differential evolution and CMA-ES batches, and run a six-axis grid method in the dimensionless log-ratio coordinates. Give that grid two layouts with four points on every axis, one on the box walls and one shifted into the interior, so each layer has 4096 joint evaluations. Identify discrete basins by steepest descent to face-adjacent neighbors, keep the eight lowest basins, refine each basin for two more grid levels, and polish each terminal root with bounded Nelder-Mead at 8000 evaluations. Treat the two optimizer batches as two replicates of the current method, and treat the two grid layouts as two replicates of the six-axis grid. After these completed runs, take the lowest verified objective as the target. A method is eligible if each replicate reaches that target plus 0.1 mm. Then record evaluations, core hours, and wall time, and apply the selected method at every remaining admitted scale."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_007",
    "options": {
      "A": "Goal: Identify the six simulator parameters on one time-step cell, using the six-parameter reference vector as the search center.\n\nPlan: Keep density at 0.3046 and search delta, alpha, kappa, kappa_bnd, stretch, and shear together. Center the search on phi_ref = (0.3046, 0.6092, 1.523e-4, 1.523e-5, 1e-6, 1e-3). Use the four full marker recordings as one joint Eq. (10) objective on the native G0 mesh with eight substeps. Alternate two-dimensional blocks in the order dynamic, bending, then in-plane, run that cycle twice, and then run a bounded joint Nelder-Mead polish. Fit a second arm that searches only alpha and delta with the other four at zero, on the same objective. Start cross-scale RG work when the six-parameter endpoints sit off the box walls and agree across starts.",
      "B": "Goal: Map how the joint two-parameter loss surface for alpha and delta changes across allowed time steps, with the other four physical parameters held at zero.\n\nPlan: Keep density at 0.3046 and set kappa, kappa_bnd, stretch, and shear to zero. Use the four full marker recordings as one joint Eq. (10) objective on the native G0 mesh. After reading the five-scale coarse surfaces and the external corner bridge, add the remaining allowed time-step levels and extra shifted grids on the same two-parameter box of alpha and delta. Report sampled minima, edge profiles, and the direction of the surface at the walls. Start a lowest-order RG fit when at least five time-step levels have interior minima in this two-parameter slice."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_008",
    "options": {
      "A": "Goal: Get a six-parameter fit on the G2 cloth and treat mesh spacing on that cloth as the spatial-scale ladder.\n\nPlan: Seal the converged G2 cell that uses the M1 rest seed and run the same three-path six-parameter identification on the G2 cloth of size 0.42 by 0.594 m. After the G2 search, hold the cloth area fixed and change the mesh counts so that the twenty markers sit on mesh nodes. Use the mesh spacing on this fixed G2 area as the spatial-scale sequence. If a G2 mesh cell stays inside the box and the three paths agree, add a second mesh rung on the same cloth before any flow fit.",
      "B": "Goal: Get a six-parameter fit on the G2 cloth and treat the G0, G1, and G2 sheet areas as the spatial-scale ladder.\n\nPlan: Seal the converged G2 cell that uses the M1 rest seed and run the same three-path six-parameter identification that was used on G0 and G1. Treat G1 and G2 as the two ends of a physical interval and keep G0 as an outer diagnostic geometry. After the G2 search, rebuild the minima, walls, and path scatter for G0, G1, and G2 against sheet area, and read that area sequence as the spatial-scale trend. If the three G2 paths stay inside the box and agree, add a second G2 member and then a denser area ladder before any flow fit."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_009",
    "options": {
      "A": "Goal: Find six-parameter endpoints at mesh k=4 with grouped alternating search.\n\nPlan: On each search path at k=4, continue the three physical pairs through four rounds on the same path. After round one, round two, and round four, run the same bounded joint Nelder-Mead polish on all six parameters. Record the endpoint, the objective, and the cost at each of those round counts.",
      "B": "Goal: Find six-parameter endpoints at mesh k=4 with grouped alternating search.\n\nPlan: On each search path at k=4, optimize the three physical pairs for two rounds. Use a coarse grid in round one and a fine grid in round two. After round two, run one bounded joint Nelder-Mead polish on all six parameters and take that point as the path result."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_010",
    "options": {
      "A": "Goal: Test whether the mid-SR MultiHMR DTW row stays after leave-one-out, and whether that row pattern appears on two more HMR sources.\n\nPlan: Run the leave-one-out cell, clip, and fold pipeline on the MultiHMR mid-SR dtw_positive binary DTW and contact rows. Call a cell degenerate when 4-channel Brier is below 1e-6 and scalar Brier is above 0.5. Convert the WHAM-repaired motions to the same joint format, and re-score the same 720 rollouts with raw MultiHMR and with WHAM-repaired. Use the high-SR geometric rows and the mid-SR dtw_positive DTW row as the pattern for those new HMR scores.",
      "B": "Goal: Test whether the GVHMR and MultiHMR row means stay under a 0.001 4-channel Brier gate and under leave-1, leave-3, and leave-5 cell drops.\n\nPlan: Recompute the GVHMR and MultiHMR per-cell scores. Call a cell degenerate when 4-channel Brier is below 0.001 or scalar Brier is above 0.95. For each panel, filter, and scalar, report the mean after dropping the top 1, 3, and 5 cells, and record any sign change. Include the mid-SR unfiltered binary DTW row. Repeat the binary fits on five fold seeds. Then re-score the same rollouts with raw MultiHMR and with WHAM-repaired."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_011",
    "options": {
      "A": "Goal: Test ranking robustness and MultiHMR training failure on the existing BeyondMimic-R18b and GMR panel.\n\nPlan: Check SHA256 hashes and per-frame diffs of the four HMR caches. Compare MultiHMR and WHAM 12-clip sets on joint range, root velocity, jitter, and contact rate. Retrain BeyondMimic-R18b on the WHAM-repaired 12-clip set with three PPO seeds. Rebuild the metric-subset ranking so logistic, MLP, and GBDT each use a matching 4-channel baseline. Score that ranking with Brier, ECE, calibration slope, and weighted Brier, and rerun the tables on the 81-clip EMDB locomotion panel.",
      "B": "Goal: Test a second tracker family or a second retargeter on the existing 24-clip WHAM panel.\n\nPlan: Load OmniTrack, SONIC, ResMimic, GMT, ProtoMotions, and MaskedMimic, and run a short actor forward pass on existing EMDB clips. Load OmniRetarget and NMR, and convert the current WHAM-repaired SMPL trajectories to G1 joints. If a second tracker yields a usable checkpoint, run the 24-clip, 30-rollout missing-value rescore that is used for BeyondMimic-R18b. If a second retargeter yields G1 trajectories, retrain BeyondMimic-R18b with the iter-1000 success-rate gate of 0.30 and rescore the same 24-clip panel. Write a load-failure record for each candidate that does not complete a forward pass."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_012",
    "options": {
      "A": "Goal: Test whether any one 1D scalar can predict humanoid-tracker rollout success by beating a matched four-channel baseline on Brier score.\n\nPlan: Keep the current panel with the BeyondMimic-R18b tracker, the GMR retargeter, and the 24-clip EMDB locomotion subset. Score MPJPE, DTW, foot-and-root MPJPE, contact-aware error, and jitter against a matched-family four-channel baseline with clip-grouped five-fold Brier. Vary NaN handling, combiner family, and risk function, and keep the three-seed fresh-rollout DTW check. Treat a scalar as a predictor only when it stays better than the four-channel baseline on all of those slices. Write the next result from the current tables as this dominance test, where no subset meets the gate and fresh-rollout DTW stays inconclusive.",
      "B": "Goal: Rank which of the five 1D scalars, used alone or in pairs, can serve as proxies for humanoid-tracker rollout success on the current panel.\n\nPlan: Keep the current panel with the BeyondMimic-R18b tracker, the GMR retargeter, and the 24-clip EMDB locomotion subset. Score MPJPE, DTW, foot-and-root MPJPE, contact-aware error, and jitter with clip-grouped five-fold Brier on the current subset-by-combiner matrix. Report which scalar ranks first when only one proxy is used, and report the score of each of the other four used alone. Report all ten pairs and the change when a second proxy is added to the stronger member of the pair. Keep the NaN-handling, combiner, and HMR slices inside those rankings."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_013",
    "options": {
      "A": "Goal: See which of three new PPO seeds on the R203 WHAM 12-clip mix pass a success-rate gate at 1000 training iterations, and collect rollouts from the seeds that pass.\n\nPlan: Retrain PPO seeds 7, 13, and 23 in parallel on the R203 12-clip WHAM mix. Train each seed toward 8000 iterations, and stop a seed if its success rate at iteration 1000 is below 0.30. For every seed that stays above that gate, run 12 clips for 30 episodes each. Re-score the five post-hoc 1D proxy subsets on those rollouts. Record how many of the three seeds pass or fail the 1000-iteration gate.",
      "B": "Goal: Train one new PPO seed on the R203 WHAM 12-clip mix for 8000 iterations, and evaluate the five post-hoc 1D proxies on that checkpoint's 12-clip rollouts.\n\nPlan: Retrain one new PPO seed on the R203 12-clip WHAM mix for the full 8000 iterations, using the same training recipe as the historical seed-0 run. After iteration 8000, run 12 clips for 30 episodes on that checkpoint. Re-score the five post-hoc 1D proxy subsets and the adjacent-size paired tests on this panel. Place the new numbers beside the historical 8000-iteration WHAM three-checkpoint panel."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_014",
    "options": {
      "A": "Goal: Measure how four pre-rollout geometric channels relate to six post-rollout quantities, and how those six post-rollout quantities relate to one another.\n\nPlan: From the existing retargeted reference trajectories, compute foot slide, joint jitter, penetration, and root height. Join these four channels with six post-rollout numbers taken per clip: success rate, mean DTW, mean MPJPE, mean foot-plus-root MPJPE, mean contact, and mean jitter. Compute rank correlations for two questions: whether the four pre-rollout channels predict the six post-rollout numbers, and whether the six post-rollout numbers agree with one another. If the pre-rollout channels do not predict the post-rollout numbers, report only the post-rollout agreement question.",
      "B": "Goal: Measure whether five post-rollout 1D summaries can replace Brier when each clip has few episodes.\n\nPlan: Reuse the existing 12-clip by 30-episode rollout table. For episode counts of 1, 3, 5, 10, and 30, compute Brier from the success labels and compute the mean of each of the five 1D summaries. Compare the cross-validation standard error of Brier with the standard error of each 1D summary at every episode count. Record whether the 1D summary has a smaller standard error than Brier at 1 or 3 episodes."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_015",
    "options": {
      "A": "Goal: Test whether the submitted post-rollout metric findings still hold when the GVHMR panel grows from 12 clips to 81 clips.\n\nPlan: Train a BM PPO tracker on the 81 GVHMR clips with 8,000 iterations and 4,096 environments. After training, run 30 IsaacLab rollouts per clip on that checkpoint. Collect success rate, DTW, MPJPE, foot and root error, jitter, and contact from these rollouts. Recompute Spearman rank alignment, Cox time-to-failure, and DeltaBrier on the 81-clip panel, and compare each finding with the 12-clip panel.",
      "B": "Goal: Test whether the submitted post-rollout metric findings still hold when the GVHMR panel grows from 12 clips to 81 clips.\n\nPlan: Use the BM-R18b checkpoint as the tracker for the expanded panel. Run 30 IsaacLab rollouts on each of the 81 preprocessed EMDB GVHMR clips. Collect success rate, DTW, MPJPE, foot and root error, jitter, and contact from these rollouts. Recompute Spearman rank alignment, Cox time-to-failure, and DeltaBrier on the 81-clip panel, and compare each finding with the 12-clip panel."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_016",
    "options": {
      "A": "Goal: Measure held-out predictive adequacy of artifact-summary scalars across more than one upstream combination.\n\nPlan: Pre-register the estimator and the decision rule. Collect a rollout panel that includes at least two HMR families and at least two retargeters or two tracker families. On held-out clips, score each artifact-summary scalar with a held-out Brier-score difference or an equivalent proper scoring rule. Compute cluster-aware intervals at the clip level or with HMR-by-retargeter random effects. Put every tested panel and every tested metric in one primary table with a multiplicity correction.",
      "B": "Goal: Submit the current timeout-metric ranking study to the NeurIPS Datasets and Benchmarks Track.\n\nPlan: Use the seven existing BM-R18b and GMR panels as the analysis set. Use the E16 clip-bootstrap aggregate partial Spearman as the primary estimator after control for episode length. Report MPJPE, foot-plus-root, and contact as the metrics whose intervals exclude zero, and report DTW and jitter as the metrics whose intervals include zero. Put the E15 and E21 VB GLMM fits in the appendix and add the E23 simulation rates as the calibration of those fits. Keep timeout as the success label, exclude short-trajectory DTW rows, and submit the rewritten paper to the NeurIPS Datasets and Benchmarks Track."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_017",
    "options": {
      "A": "Goal: Run the E8 and E9 held-out predictive-adequacy experiment described in idea.md and proposal.md.\n\nPlan: Collect a factorial rollout panel with 4 HMR families, 3 retargeters, and 3 trackers. Use 30 clips and 30 rollouts in each cell, for about 97,200 rollouts, and add a PHUMA oracle row of 8,100 rollouts. Score each motion with the five artifact-summary scalars, the three motion-derivative scalars, and a learned 1D projection. Fit five-fold clip-held binomial GLMs and report delta Brier. Fit a crossed random-effect GLMM with HMR and retargeter groups, apply Holm step-down at alpha 0.1 on the five artifact-summary scalars, and run nested cluster bootstrap from HMR to retargeter to clip.",
      "B": "Goal: Run an 81-clip panel that crosses HMR source and tracker checkpoint on the same motions.\n\nPlan: Use 81 EMDB clips, 3 HMR sources (GVHMR, WHAM, and MultiHMR), and 2 tracker checkpoints (weak and fully trained). Train a PPO tracker on the 81-clip set at each checkpoint, then collect 10 rollouts per clip. Put the GVHMR, WHAM, and MultiHMR versions of one raw clip in the same CV fold, and resample by clip identity for cluster bootstrap. Report the interaction of metric, HMR, and checkpoint, the sign consistency of each metric, the gap between source-aware and source-blind predictors, leave-one-HMR-out scores, and 95 percent clip-cluster bootstrap intervals."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_018",
    "options": {
      "A": "Goal: Decide whether the V2 numeric and api_shortcut positive cells stay positive under a target-disambiguating LLM judge and a non-target task accuracy scrub gate.\n\nPlan: Run an LLM judge that inserts the canonical hidden target into the prompt and asks whether the trace aims at that value. Start with the numeric open cell and one judge model on the Qwen3-4B cached traces. Score the raw reasoning view and the scrubbed view against the matched target-aware action regex at FPR 0.10. In the same round, ask a solver to answer the non-target task from the scrubbed trace, and compare that accuracy with the raw-trace accuracy. Expand the judge to the other three V2 positive cells and to a second judge model after the first cell shows a type-2 delta of at least 0.10 at FPR 0.10.",
      "B": "Goal: Decide whether the V2 numeric and api_shortcut positive cells stay positive under a target-blind LLM judge and a topic-retention scrub gate.\n\nPlan: Run a target-blind LLM judge with gpt-5 and gpt-4o-mini on the four V2 positive cells. The cells are numeric and api_shortcut, each in the open frame and the suppress frame, using the Qwen3-4B cached traces. Score the raw reasoning view and the deterministic-scrubbed view against the matched target-aware action regex at FPR 0.10. Take every cell, judge, and view combination as the V3 primary family. In the same round, patch the deterministic scrubber so that it redacts only literal target strings and metadata tokens. Then re-audit non-target topic retention on the same rows and require a score of at least 0.90."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_019",
    "options": {
      "A": "Goal: Measure extra catch rate of a thought-chain judge at a 10 percent false-alarm cap after the hidden number is swapped, when the judge is shown the hidden answer and when the judge is not shown it.\n\nPlan: Split the cached judge scores by whether the prompt includes the hidden answer. On scores with the hidden answer, keep cells whose false-alarm rate is at most 10 percent and compute extra catch rate over the action monitor. On scores without the hidden answer, compute the same extra catch rate and the false-alarm rate on swapped items. Replace every target number string with a placeholder and recompute extra catch rate on the with-answer scores. On the cached files, run a two-sample test of original versus swapped scores in each arm, and join the two arms on matching family, generator, and budget cells.",
      "B": "Goal: Measure extra catch rate of a thought-chain judge that is not shown the hidden answer, at a 10 percent false-alarm cap, after the hidden number in each item is swapped.\n\nPlan: Use the cached judge scores in which the judge sees only the thought text. Cover the numeric, API, covert, and code-grader families and the three generator models already scored. For each family and generator, count how many cells still meet the 10 percent false-alarm cap on swapped items, and record the false-alarm rate on those swapped items. Also compute extra catch rate from the cached scores in which the judge was shown the hidden answer. On the same cached score files, compare the score distribution of original cheat items and swapped items, then make the family-by-generator grid and outcome table from those counts."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_020",
    "options": {
      "A": "Goal: Account for the oracle and deployable gap by testing a procedural channel and a referent channel on the cached traces.\n\nPlan: From the cached high-score judge rationales, treat each trace as a procedural channel that names the cheat shape and a referent channel that names specific constants and nearby arithmetic. Report the alltargets-scrubbed sixteen-row table with its raw-view label, and treat the sixteen pass cells and the sixteen fail cells as a function of leftover arithmetic in the trace. Run a cache-only count of which channel each panel cites, and a cache-only regression of leftover arithmetic mass against oracle score-separation p-values on those thirty-two cells. Run a random-value injection that gives the judge a false canonical target, and a deployable repeat after stripping the grader-information block from the public task. State the paper main claim as this two-channel account of why deployable scores on canonical-cheat and substitution-cheat traces stay the same, and why leftover referent mass predicts oracle separation.",
      "B": "Goal: Account for the four oracle and deployable cells on raw and scrubbed traces with one prompt-time canonical-target-access mechanism.\n\nPlan: Put the alltargets-scrubbed count as zero of sixteen on the scrubbed view in the abstract and in the section 5.4 table. Write a proposal update that sets the oracle judge as the main estimand and argues novelty as the cost of losing private target metadata. Inspect the deployable prompt for leftover evaluator fields and few-shot target text, and rerun that arm after a patch if the leak is present. Write a mechanism discussion in which the oracle-raw cell passes because the prompt includes the canonical target, the deployable-raw cell fails because that field is missing, and both scrubbed cells fail because scrubbing removes the same literal from the trace. Restate the paper contribution as: chain-of-thought monitoring works only when the judge has prompt-time access to the canonical target, and a trace-level scrub does not replace that access. On the cached scores, check that the oracle distribution on scrubbed traces matches the deployable distribution."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_021",
    "options": {
      "A": "Goal: Close the V3 review with the V4 mechanism package, and collect the stripped-prompt deployable repeat and the random hidden-target injection from 20-item OpenAI batch-API calls.\n\nPlan: Strip the grader-information block from the public task and call the deployable gpt-5 and o3 judges on the numeric_probe and api_shortcut grid across 12 shards, three budget tiers, and three generators, with 20 items per cell, as R66. From cache, score existing rationales for procedural versus referent features as R67, and regress surviving arithmetic residue on the 32 alltargets cells against oracle KS p as R68. Inject a random hidden-target value and a blank hidden-target value into the oracle prompt and call gpt-5 and o3 on the 24-cell grid with 20 items per cell as R69. Audit 50 traces with a non-OpenAI judge as R70. After the reviewer reads the 20-item R66 and R69 numbers, and after the user agrees, call those two batch designs again at 200 items per cell for the paper tables.",
      "B": "Goal: Close the V3 review with the V4 mechanism package, and collect the stripped-prompt deployable repeat and the random hidden-target injection from 200-item OpenAI batch-API calls.\n\nPlan: Strip the grader-information block from the public task and call the deployable gpt-5 and o3 judges on the numeric_probe and api_shortcut grid across 12 shards, three budget tiers, and three generators, with 200 items per cell, as R66. From cache, score existing rationales for procedural versus referent features as R67, and regress surviving arithmetic residue on the 32 alltargets cells against oracle KS p as R68. Inject a random hidden-target value and a blank hidden-target value into the oracle prompt and call gpt-5 and o3 on the 24-cell grid with 200 items per cell as R69. Audit 50 traces with a non-OpenAI judge as R70. Enter the 200-item R66 and R69 numbers in the paper tables for the leak-free deployable boundary and the random-Q causal figure."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_022",
    "options": {
      "A": "Goal: Measure whether PDE language context improves CP feature Utility when gpt5.6-sol proposes the candidate bank.\n\nPlan: After the operator tuner and the non-Oracle solver competence checks, run PDE semantic Utility on Poisson and Helmholtz tasks at d=5, d=10, and d=20. Use gpt5.6-sol as the LLM proposer for the Full, NoSemantics, and wrong-context arms. Compare those banks with matched Random-CP, Fixed-Library, Fourier library, a deterministic forcing parser, and Oracle under the same tuning budget. Require a Full versus Random median ratio of at least 1.20. Run about 1 percent of API calls on development tasks, then 10 percent, then the full evaluation.",
      "B": "Goal: Measure whether PDE language context improves CP feature Utility when DeepSeek proposes the candidate bank.\n\nPlan: After the operator tuner and the non-Oracle solver competence checks, run PDE semantic Utility on Poisson and Helmholtz tasks at d=5, d=10, and d=20. Use DeepSeek as the LLM proposer for the Full, NoSemantics, and wrong-context arms. Compare those banks with matched Random-CP, Fixed-Library, Fourier library, a deterministic forcing parser, and Oracle under the same tuning budget. Require a Full versus Random median ratio of at least 1.20. Run about 1 percent of API calls on development tasks, then 10 percent, then the full evaluation."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_023",
    "options": {
      "A": "Goal: Test whether LLM-proposed CP features reduce end-to-end solver time on Allen-Cahn, Black-Scholes, wave, and anisotropic diffusion tasks.\n\nPlan: Run an end-to-end time-to-error study on Allen-Cahn, Black-Scholes, wave, and anisotropic diffusion tasks. Use gpt5.6-sol as the proposer. On each task card, describe the operator, domain, boundary conditions, and qualitative physics. Expand the proposed structures with discretized constant enumeration, select them with elastic-net, and attach them to a zero-gated PINN. Compare LLM-LATTICE with vanilla PINN, Random-CP, Fixed-Library, and Oracle. Score success by LLM-LATTICE speedup over vanilla PINN and Random-CP for each family.",
      "B": "Goal: Test whether parser-extracted CP features reduce end-to-end solver time on Poisson and Helmholtz tasks at dimension 5, 10, and 20.\n\nPlan: Run an end-to-end time-to-error study on the 12-task Poisson and Helmholtz evaluation suite at dimension 5, 10, and 20. Use the deterministic forcing parser as the proposer. Also run gpt5.6-sol on the same discretized constant enumeration, elastic-net selection, and zero-gated PINN pipeline. Compare Parser-LATTICE and LLM-LATTICE with vanilla PINN, Random-CP, Fixed-Library, Fourier features, and Oracle. Score success by Parser-LATTICE speedup over vanilla PINN, Random-CP, and the strongest other baseline."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_024",
    "options": {
      "A": "Goal: Finish the remaining readiness runs and then run the repeated-seed LATTICE matrices on the coordinate and rank-1 feature network.\n\nPlan: Run the random-feature scale and ridge cells on the v12 task. Run the three DeepONet arms for 1000 steps. Build the 100-dimensional HJB reference task. Then run the grammar, rank K, selector, operator-learning, and HJB experiments with repeated seeds. Keep the LATTICE MLP input as the training-point positions together with the rank-1 function values.",
      "B": "Goal: Train the next LATTICE MLP cells with rank-1 function values, and with a short-trained basic MLP, as the input.\n\nPlan: Train a basic coordinate-only MLP for 1000 steps and then keep those weights fixed. Give every later network the same size and the same start weights. Run LATTICE and RandomCP on four inputs: positions with rank-1 values, rank-1 values only, basic MLP output with rank-1 values, and basic MLP output with residual and rank-1 values. Train each cell on the v12 task for 3000 steps and record relative L2, residual, and gradient curves."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_025",
    "options": {
      "A": "Goal: Find out if language-conditioned proposals beat matched random banks and Vanilla after the twelve-task zero-init study.\n\nPlan: Take rank-one functions to be products of one-dimensional factors. Collect No-Semantics and Shuffled language arms and add more task clusters under zero initialisation and the Shotgun host. Draw matched random banks from this product grammar with the same candidate count and selection budget. Report paired accuracy and time to the existing error target on the added tasks.",
      "B": "Goal: Find out if language-conditioned proposals beat matched random banks and Vanilla after the twelve-task zero-init study.\n\nPlan: Take rank-one functions to be any scalar functions of one or more inputs that can be evaluated quickly at sampled points. Include functions that are not products, such as the sine of the norm of the input vector. Build a grammar, a prompt, a validator, and a matched random generator that can express this class. Compare Vanilla, matched random, and language arms that share this grammar, first on one development task and then on four task cards."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_026",
    "options": {
      "A": "Goal: Measure residual learning against same-input classical estimators on the opened 22-event R82 panel.\n\nPlan: Use the opened R82 panel as the next run. Compare PhaseCNN with prior-solver, six-channel ridge, TV assimilation, convex fusion, and Advect-Fuse-BP. Give every arm the same six channels, the same none, M, and T delivery, and the same 480-step correction, and tune each control only by training-event-deletion CV. Report absolute solver levels, relative effects versus the 0.25 mm per hour LUT step, the AA-PP over AA-solver fraction, and the split by event activity. State in advance that a loss to the strongest same-input control fails the learning claim, that a win under RMSE 0.5 percent and band 1 percent is under the declared materiality bars, and that a signal only on low-activity days is a regime-limited claim.",
      "B": "Goal: Measure residual learning on the sealed 22-event R82 evaluation with the current solver and AA-PP controls.\n\nPlan: Use the already collected R82A and R82B fields as the next run. Compare the T-treated aligned residual with the coarse-only 480-step solver on RMSE, MAE, FSS, and both registered bands. Use the exact-marginal AA-PP contrast as the information-free control. Keep five training seeds and the current 22-event panel. Enter the seed-by-event intervals into C2, C3, and C5, and enter the C4 surface with the two adverse bias cells as a qualification. Carry the band tally of 18 favorable, 2 crossing zero, and 0 adverse, and the C4 tally of 6 favorable, 4 crossing zero, and 2 adverse. Promote these numbers into the claim matrix and send version 0 to review."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_027",
    "options": {
      "A": "Goal: Choose the next Stage 0 step after the two-by-two path and prediction-target table on 100k sentences.\n\nPlan: Download the smallest Meta LCM checkpoint and run the project concept benchmark on the same validation split. Confirm that the checkpoint loads and that it produces cosine and retrieval scores. Then train an LCM from scratch with the official LCM training recipe on the same data. Record concept cosine and predicted-vector norm from that training run. After those two reference runs, try ECF by changing a Meta checkpoint to the ELF objective, or by training from scratch with the ELF method, and compare the two paths if a later run has a problem.",
      "B": "Goal: Choose the next Stage 0 step after the two-by-two path and prediction-target table on 100k sentences.\n\nPlan: Take the 100k-sentence table as the Stage 0 outcome for the three claims. Record that the linear path and the cosine path give the same next-concept cosine under x-prediction. Record that four-step and forty-step scores match, and that direct MSE is higher than flow matching. Write that Claim 1, Claim 2, and Claim 3 are falsified. Stop new Stage 0 runs, and ask the user to choose among stopping this project, rewriting the work as a concept-generator design guide, or searching for an ECF mechanism other than noise path or step count."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_028",
    "options": {
      "A": "Goal: Close the three original claims from the 100,000-sentence 2 by 2 runs and choose a new direction.\n\nPlan: Record the finished linear-path x-prediction run and the cosine-path x-prediction run as the Stage 0 outcome. Record that both paths give a concept cosine near 0.376. Record that 4 sampling steps and 40 sampling steps give the same score, and that MSE cosine is 0.383. Set the few-step flow-matching claim, the downstream text-quality claim, and the OmniSONAR claim to not supported. Launch no new training run. Ask the user to choose among leaving this workspace, rewriting the work as a concept-space generator design guide, or looking for an ECF difference that is not path and not step count.",
      "B": "Goal: Run a Meta LCM benchmark and an official LCM training reproduction, then continue ECF.\n\nPlan: Download the smallest Meta LCM checkpoint and measure concept cosine and retrieval on the same validation split used by the current runs. Train an LCM from scratch with the official LCM training recipe, and measure concept cosine on the reproduced model. After both LCM references exist, run ECF in two ways. One way changes the Meta checkpoint to a flow-matching next-concept generator. The other way trains a flow-matching model from scratch with the same evaluation. Use both paths to debug later ECF runs."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_029",
    "options": {
      "A": "Goal: Measure LCM scaling as a data-size curve of concept cosine for one large MSE-LCM model.\n\nPlan: Keep parameter count fixed at the 1.6 billion parameter MSE-LCM recipe. Train on nested FineWeb-Edu sets of 0.5 million, 2.5 million, and 5 million sentences, and add 10 million or 20 million sentence runs of the same model. Record best concept cosine at each size and the training step at which overfitting starts. Use the rise of cosine and the later onset of overfitting as the scaling curve. On the largest set, continue past 10k steps if cosine is still increasing at the last checkpoint.",
      "B": "Goal: Measure LCM scaling as the data exponent and the parameter exponent of next-concept loss.\n\nPlan: Use the newer English FineWeb release and MSE-LCM models with fewer than 200 million parameters. Take the compute-efficient data-to-parameter ratio as about 20 to 1, and treat a factor of 20 above that ratio as the infinite-resource slice. Fit a power law of next-concept squared error, or an equivalent loss, versus data size in the large-parameter slice and versus parameter count in the large-data slice, including a constant loss floor. Collect several sizes on each axis so that each exponent can be identified. Target both exponents in the range 0.075 to 0.125."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_030",
    "options": {
      "A": "Goal: Measure whether trained LCM models obey the required data and parameter scaling exponents.\n\nPlan: Build nested training sets from the latest English FineWeb crawl. Train MSE-LCM models with fewer than 200 million parameters along a data-size axis at one large-parameter setting and along a parameter-size axis at one large-data setting. Fit validation loss with an irreducible floor, and estimate alpha_D and alpha_P. Count the scaling gate as passed only if both exponents fall between 0.075 and 0.125. Keep the existing 1.6 billion parameter checkpoints for a later matched paper-metric test on the ROCStories reference split.",
      "B": "Goal: Score the finished MSE and Two-Tower checkpoints on the original LCM paper metrics across all available evaluation sets.\n\nPlan: Take the selected checkpoint from each of R29a, R29b, R29c, R30a, and R30b. Score each checkpoint on the six R26 ROCStories, C4, and Gutenberg splits and on the fixed FineWeb and Wikipedia validation sets, for forty evaluations in one run. Use the same evaluator, the same seed, and the same sample counts. Report L2, round-trip L2, PAR, contrast accuracy, and mutual information. Treat the ROCStories test absolute thresholds and the Two-Tower versus matched MSE deltas as the success gates."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_031",
    "options": {
      "A": "Goal: Measure the LCM data-axis and parameter-axis scaling exponents with the project R36 training loop.\n\nPlan: Use the recorded R36 Stage 3 cell list, the 250k cosine recipe, the one-epoch alternate recipe, and the exponent interval 0.075 to 0.125. Train each cell in the project R36 loop. That loop reads batches from the official dataloader, scores next-sentence mean squared error with the official criterion, and uses official gradient normalization. Project code then performs overflow retries, optimizer steps, checkpoints, and validation, and the two exponents are fit from these cells.",
      "B": "Goal: Measure the LCM data-axis and parameter-axis scaling exponents with runs of the pinned LCM Trainer.\n\nPlan: Use the recorded R36 Stage 3 cell list, the 250k cosine recipe, the one-epoch alternate recipe, and the exponent interval 0.075 to 0.125. Train each cell by calling the pinned large_concept_model Trainer. This Trainer builds the recipe, loads data, computes the loss, steps the optimizer and scheduler, writes checkpoints, and runs evaluation. A project script may set paths and write receipts, and each cell stores the official source and config."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_032",
    "options": {
      "A": "Goal: Measure Kaplan scaling of LCM loss on one resource at a time, with the other resource left open.\n\nPlan: For each existing exponent pair from the official scaling cells and the mature two-axis cells, recover how data size, parameter count, and compute were set in the fit. A Kaplan data fit holds parameters large, does not hold compute fixed, and regresses loss on data size. A Kaplan parameter fit holds data large, does not hold compute fixed, and regresses loss on parameter count. If recorded cells first chose the lowest-loss data size and parameter count at a fixed compute budget, do not enter those cells into the Kaplan regression. Report R-squared for each one-resource fit, and keep a fit only when it has at least six points and R-squared is at least 0.95.",
      "B": "Goal: Bring the LCM data-axis and parameter-axis exponents into the range 0.075 to 0.125.\n\nPlan: Take the finished mature two-axis cells and the earlier official scaling cells as Kaplan measurements. The current estimates are alpha_D=0.815 and alpha_P=0.290, and the earlier pairs are 0.132 with 0.895 and 0.401 with 0.524. Keep the success rule that both point estimates, every seed fit, and every leave-one-scale fit lie in 0.075 to 0.125, and that the two exponents differ by at most 0.03. Because the mature estimates lie outside that range, audit the official architecture and loss, or widen the unique data and model range of the same two-axis protocol, and refit until that range and the equality check pass."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_033",
    "options": {
      "A": "Goal: Judge the current LCM two-axis scaling measurements against the Kaplan exponent interval and continue the Two-Tower run.\n\nPlan: Apply the interval 0.075 to 0.125 to the R40 values of alpha_D and alpha_P. Treat the high R-squared values as evidence that the power-law curves are stable. Inspect whether the R40 data-axis and parameter-axis exponents were obtained at matched compute so that the two values add to about one. Continue the live R41T Two-Tower training, checkpoint selection, and original five-metric evaluation while the scaling-law experiment stays open for that check.",
      "B": "Goal: Judge the current LCM two-axis scaling measurements against the point-count and R-squared rule and continue the Two-Tower run.\n\nPlan: Apply the rule of at least six data points and R-squared at least 0.95 to the R40 data-axis and parameter-axis fits. Store the measured SONAR-MSE exponents beside the earlier interval adjudication. Continue the live R41T Two-Tower training, checkpoint selection, and original five-metric evaluation. Measure the same scaling relation again later under other loss or data conditions. Ask the human if later results differ by a large amount and cannot be explained."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_034",
    "options": {
      "A": "Goal: Check the mapped ELF mechanism on the official LCM trainer with a real batch and a short resume.\n\nPlan: Keep the R41T Two-Tower run on its selection and original-metric path. In parallel, connect the author ELF numerical rules to the official LCM trainer by adapting the sentence representation and the conditioning interface. On the official GPU runtime, run one real FineWeb batch forward and backward, check that every new parameter has a finite gradient, and compare a short resumed update with an uninterrupted control. Cap this run at ten steps.",
      "B": "Goal: Finish the Two-Tower baseline and then run the first ELF-on-LCM claim comparison.\n\nPlan: Keep R41T as the only active run until a checkpoint is selected by the existing validation-loss rule and the original five metrics are published. After those receipts exist, implement one ELF-on-LCM recipe from the completed fidelity map and train it for a matched 8-step and 16-step comparison against Diffusion-LCM-40 on the same data and architecture. Use that trained comparison as the first evidence for the primary claims."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_035",
    "options": {
      "A": "Goal: Complete the matched ECF versus Diffusion-40 comparison and measure inference complexity with sampling-step MAC counts in FLOPs.\n\nPlan: Continue the ROCStories, C4, and Gutenberg evaluations that compare ECF-4, ECF-8, ECF-16, and ECF-40 with Diffusion-40 on the same architecture, data, and five quality metrics. For each sampling-step arm, count the model calls made by the sampler and the guidance recipe, multiply those calls by the architecture and task-shape multiply-accumulate counts, and report per-target complexity in FLOPs with one MAC counted as two FLOPs. Use that ledger, together with the five quality metrics, as the efficiency evidence.",
      "B": "Goal: Complete the matched ECF versus Diffusion-40 comparison and measure inference complexity with wall-clock prediction time.\n\nPlan: Continue the ROCStories, C4, and Gutenberg evaluations that compare ECF-4, ECF-8, ECF-16, and ECF-40 with Diffusion-40 on the same architecture, data, and five quality metrics. Time each sequential online prediction on one A100 after a short uncounted warm-up, with CUDA synchronization around every timed call, and omit model load, decoding, encoding, scoring, and file I/O from the timer. Save per-target durations and a paired document-cluster interval on Diffusion-minus-ECF time, and use that interval as the efficiency evidence."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_036",
    "options": {
      "A": "Goal: Measure inference complexity for the matched ECF and Diffusion-40 comparison.\n\nPlan: After the matched ECF and Diffusion-40 evaluations are collected, measure generation latency for ECF-4, ECF-8, ECF-16, ECF-40, and Diffusion-40 on one exclusive A100. Use the sealed generation cards and the same-card timing protocol from the matched evaluation. Keep self-conditioning and classifier-free guidance inside the timed interval. Record wall-clock generation time as the complexity metric for the efficiency claim.",
      "B": "Goal: Measure inference complexity for the matched ECF and Diffusion-40 comparison.\n\nPlan: After the matched ECF and Diffusion-40 evaluations are collected, count registered sampling steps times multiply-accumulate operations for ECF-4, ECF-8, ECF-16, ECF-40, and Diffusion-40. Compute the MAC counts from the frozen 1.645B architecture, the sealed generation cards, and the observed call traces, including guidance and self-conditioning branches. Report the product in FLOPs, with one MAC equal to two FLOPs. Use this step-times-MAC ledger as the complexity metric for the efficiency claim."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_037",
    "options": {
      "A": "Goal: Compare ECF with matched Diffusion-40 on C4, ROCStories, and Gutenberg after the R46T run.\n\nPlan: Evaluate ECF-4, ECF-8, ECF-16, ECF-40, and Diffusion-40 on both splits of each corpus with the frozen target lists and metrics. Load the R46T raw weights for every ECF arm. Keep the Diffusion-40 checkpoint and the generation cards unchanged. Use the three corpus tables as the evidence for C1 and C2.",
      "B": "Goal: Compare ECF with matched Diffusion-40 on C4, ROCStories, and Gutenberg after the R46T run.\n\nPlan: Evaluate ECF-4, ECF-8, ECF-16, ECF-40, and Diffusion-40 on both splits of each corpus with the frozen target lists and metrics. Load the R46T EMA weights for every ECF arm. Keep the Diffusion-40 checkpoint and the generation cards unchanged. Use the three corpus tables as the evidence for C1 and C2."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_038",
    "options": {
      "A": "Goal: Set the FineWeb-Edu smoke budget and the 20 to 1 exposure for a later 50 million parameter ECF versus Diffusion pilot.\n\nPlan: Count GPT-2 tokens only on sentences after the first sentence of each document when filling the 100 million token smoke tier and when setting the 20 to 1 data ratio. Treat the first sentence as a context prefix and keep a separate raw token total over the full document. After the smoke set passes, train the 50 million parameter arms on the same selected rows with about 1 billion unique raw target tokens.",
      "B": "Goal: Set the FineWeb-Edu smoke budget and the 20 to 1 exposure for a later 50 million parameter ECF versus Diffusion pilot.\n\nPlan: Count GPT-2 tokens at every non-padding sentence position, including the first sentence of each document, when filling the 100 million token smoke tier and when setting the 20 to 1 data ratio. Keep a separate total for tokens at positions that have a previous sentence in the same document. After the smoke set passes, train the 50 million parameter arms on the same selected rows with about 1 billion unique tokens from this all-position target count."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_039",
    "options": {
      "A": "Goal: Test whether the current FK candidate sets beat equal-wall-clock controls on XSum using human labels.\n\nPlan: Prepare a blinded packet of 300 documents with three arms: the current FK kernel, best-of-N at the same wall-clock, and FK with isotropic jitter. Ask three annotators to label factuality, informativeness, duplicates, and set preference, and reuse 10 percent of items as repeats. Take a preference lower bound above 55 percent against each control, and factuality within 1 percentage point, as the success bar.",
      "B": "Goal: Test whether a repaired FK method beats equal-wall-clock controls on XSum using automatic evaluators.\n\nPlan: Run the next diversity-aware FK repair on XSum and score quality after removing near-duplicate outputs, coverage, and end-to-end wall-clock with MiniCheck and QAFactEval. Look at 10 to 20 blinded examples for factuality, informativeness, and duplicate problems. Take a confidence interval that stays above zero on both evaluator families after near-duplicate removal as the success bar."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_040",
    "options": {
      "A": "Goal: Measure selective_ci_bottom50 on the R49 selected-ID MiniCheck semantic-set endpoint.\n\nPlan: Aggregate the already-finished MiniCheck scores on the registered selected-ID set from the 512-document and 3-seed R49 run. Compare semantic top-3 utility against identity and the named equal-wall-clock controls. Record the generation-stage source-NLI self-check and the 96-document R53A calibration as source-NLI numbers. If the MiniCheck comparison is not positive, stop the remaining QAFactEval pass on the 649,728-candidate pool and run small-scale independent MiniCheck and QAFactEval checks on a disjoint calibration split. If the MiniCheck comparison is positive, score QAFactEval on the selected-ID set.",
      "B": "Goal: Finish R49 as the paper-scale confirmation of selective_ci_bottom50 on fresh XSum.\n\nPlan: Continue independent evaluation of the merged 512-document and 3-seed pool of 649,728 candidates. Take the generation-stage source-NLI paired bootstrap as the directional result. Let MiniCheck, which has already scored the full pool, and QAFactEval, which is still running on the same full pool, both finish. Report those two independent evaluator numbers for the paper. Leave the sampler, reward, thresholds, split, and named equal-wall-clock controls unchanged."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_041",
    "options": {
      "A": "Goal: Test whether selective_ci_bottom50 beats the named controls on MiniCheck and QAFactEval.\n\nPlan: Keep the R53A winner selective_ci_bottom50 unchanged. Generate this arm against the named controls on the fresh XSum split of 512 documents with three seeds. Score those candidates with MiniCheck and QAFactEval. Report the 512 by 3 numbers as the confirmation of the main comparison.",
      "B": "Goal: Test whether selective_ci_bottom50 beats the named controls on MiniCheck and QAFactEval.\n\nPlan: Keep the R53A winner selective_ci_bottom50 unchanged. Generate this arm against the named controls on a fresh XSum split sized to finish generation and scoring in one day. Score those candidates with MiniCheck and QAFactEval. Run a 512-document three-seed confirmation if this one-day result is positive."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_042",
    "options": {
      "A": "Goal: Run the lift pipeline on a PDE whose high-dimensional from-scratch FEX search fails.\n\nPlan: Select a PDE that has a known solution and that fails high-dimensional from-scratch FEX search. Run low-dimensional FEX search until a skeleton is recovered. Lift that skeleton with the existing three-gate audit at d=10, d=20, d=50, and d=100. Record the low-dimensional search result, the high-dimensional lift residual, and the high-dimensional from-scratch outcome on the same PDE. Run an executable external baseline with multiple seeds.",
      "B": "Goal: Run the next round on the current accepted families and the Poisson HD-TLGP comparison.\n\nPlan: Run the official HD-TLGP code on polynomial Poisson at d=2 with three to five seeds, and report the mean and the standard deviation. Sweep the low-dimensional fit threshold and the high-dimensional probe threshold on the composite families and the perturbed composite families. Add two or three structures to the macro library, and compute the false-accept rate on the current reject families again. Write the external baseline, the perturbed-family acceptances, and the pairwise lifts as partial in the claim list."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_043",
    "options": {
      "A": "Goal: Answer the V6 review by testing Conservation recovery from a systematic unary linear-combination library and adding a guided GP baseline.\n\nPlan: Remove the sine, cosine, cube, exponential, and quartic anchor macros from the library. Add unary linear-combination macros whose amplitude, linear coefficients, and bias are learned from data. Rerun Conservation, Poisson, radial, and a reject family under this library, and check that Conservation still selects the sine form with lift error below 0.001 at dimension 100 and that the audit does not newly accept a high-error lift. Run PySR on Conservation at dimensions 3, 10, and 50.",
      "B": "Goal: Answer the V6 review by presenting Conservation as a single-case study of FEX liftability and adding a guided GP baseline.\n\nPlan: Keep the current macro library, including the sine, cosine, cube, exponential, and quartic anchor macros. Rewrite the argument around Conservation as the only hard window, and present the cubic, quartic, and other candidate outcomes as part of that finding. Run PySR on Conservation at dimensions 3, 10, and 50. Count false accepts on the existing 624-cell ablation under a macro-name definition and a lift-quality definition."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_044",
    "options": {
      "A": "Goal: Test whether a d=3 FEX tree can be lifted to d=100 by fitting a linear mix of high-d coordinates at each leaf.\n\nPlan: Parse the Conservation FEX trees found at d=3. Keep the operators in each tree. Replace each leaf variable with a linear combination of the high-d coordinates. Use the original tree coefficients plus a mixing matrix with one row for each low-d variable and one column for each high-d coordinate. Set the first square block of the matrix to the identity and set the remaining entries to small random values. Fit these parameters on the high-d PDE residual and the boundary loss at d=20, d=40, and d=100 with three seeds each. Measure relative L2 error against the analytic Conservation solution. Restrict the fitted high-d formula back to d=3 and measure agreement with the original tree.",
      "B": "Goal: Test whether Helmholtz can be found at d=3 and lifted to d=100 by matching the low-d tree to the sine-of-linear-sum macro.\n\nPlan: Add Helmholtz as a target family. Use the residual Laplacian of u plus k squared times u equals zero, the box from 0 to 2 pi in each coordinate, and the closed form sine of the sum of all coordinates, with k squared equal to the dimension. Run FEX search at d=3 with five seeds and the same depth-2 grammar used for Conservation. Match each low-d tree to the sine-of-linear-sum entry in the macro list. Fit only that entry's continuous coefficients at d=20, d=40, and d=100. Run from-scratch FEX at d=30, d=40, d=50, and d=100. Record the low-d hit rate, the d=100 relative L2 error of the lift, and the from-scratch hit rate at d=40 and d=100."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_045",
    "options": {
      "A": "Goal: Test whether Conservation can be lifted from a low-d FEX tree to d=100 by a learned mixing matrix.\n\nPlan: Take the existing Conservation FEX trees from the d=3 search with 5 seeds. For each tree, replace every leaf variable x_i by a weighted sum of the high-d coordinates, and keep the original operators and coefficients. Learn the mixing weights with LBFGS on the Conservation PDE residual and the boundary loss. Lift each tree to d=20, d=40, and d=100. Report the d=100 lift rel-L2, and the rel-L2 of the lifted expression when it is restricted back to d=3.",
      "B": "Goal: Test whether Helmholtz can be lifted from a low-d FEX search to d=100.\n\nPlan: Add the Helmholtz family Laplace(u) + d*u = 0 on the cube from 0 to 2 pi in each coordinate, with Dirichlet data from u = sin(sum of all coordinates). Search with FEX at d=3, tree depth2_sub, 5 seeds, and 60 epochs. On seeds that hit, lift with the sin_anchor_sum macro at d=20, d=40, and d=100. Run scratch FEX at d=30, d=40, d=50, and d=100 with 3 seeds at each dimension. Report the low-d hit count, the d=100 lift rel-L2, and the scratch hit counts at d=40 and d=100."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_046",
    "options": {
      "A": "Goal: Choose one high-d transfer from the shape of the low-d FEX tree, and check that choice on Conservation and Helmholtz.\n\nPlan: Parse each low-d FEX tree. For a tree that wraps a sum of variables in one function, fit a model that replaces each low-d variable by a learned linear mix of the high-d coordinates. For a tree that sums the same function of each variable, fit a model that copies that function onto each high-d coordinate and adds the copies. Run both models on Conservation and on Helmholtz at d=100. Count success when Conservation with the linear mix and Helmholtz with the copied function are below 1e-3 relative L2, and the crossed pairings stay above 1e-3 or fail to fit.",
      "B": "Goal: Insert extra coordinates at successive layers of each low-d FEX tree, and reach relative L2 below 1e-3 on at least six PDE families at d=100.\n\nPlan: From each low-d FEX tree, make high-d candidates that insert extra coordinates at the leaf layer, then at the next layer up, then at higher layers. Fit the candidates in that order on the high-d PDE residual, and stop when relative L2 is below 1e-3. Keep the list of all candidates for each tree. Run five seeds at d=100 on Conservation, cosine-anchor, cubic-anchor, quartic-anchor, Helmholtz, Schrodinger, Poisson, and sum of fourth powers. Count a family when at least three seeds are below 1e-3, and continue until six families meet that mark."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_047",
    "options": {
      "A": "Goal: Test whether high-dimensional formulas can be built by trying insertion candidates at each layer of a low-dimensional FEX tree, and obtain positive lifts on at least six PDE families.\n\nPlan: From each low-dimensional FEX tree, list legal high-dimensional insertion candidates from the leaf layer upward, including leaf mixing and node or subtree replicate pooling with sum, mean, and normalized-sum aggregators. Fit the candidates with continuous optimization in that layer order, and stop when residual, boundary, and low-dimensional consistency meet the threshold. Keep every listed candidate until its fit metrics are recorded. Run this scout on at least eight families that are already in the codebase, covering signed-sum, separable-sum, moment-type, and exp(mean(cos(x))) divided by d, with five seeds and dimension 100. A family is positive when at least three of five seeds reach relative L2 below 1e-3. The scout targets at least six positive families, and it writes the full candidate list and the trial order for every tree.",
      "B": "Goal: Test whether a parser can read a low-dimensional FEX tree and assign one transfer primitive from the tree shape on Conservation and Helmholtz.\n\nPlan: Add an auto-transfer module that maps a depth-2 tree of the form unary of a binary of two leaves to leaf mixing, and maps a depth-1 tree of two identical unary leaves to unary replication. Load the existing Conservation dimension-3 search seeds and Helmholtz dimension-2 search seeds. For each seed, build both primitives, fit them at dimension 100, and record relative L2. Conservation is assigned leaf mixing and Helmholtz is assigned unary replication. The matching cells reach relative L2 below 1e-3, and the mismatched cells stay above 1e-3 or fail to optimize. The assignment rule uses tree shape and unary names taken from the tree, and it does not use PDE names or macro names."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_048",
    "options": {
      "A": "Goal: Decide how to lift a two-dimensional mean-cosine formula to high dimension, and how to treat the current Schrodinger result.\n\nPlan: Lift the constant two in the two-dimensional mean of cosines to a new fitted scale in front of the high-dimensional sum of cosines. Use a Schrodinger lift formula that, when limited to two coordinates, still includes the original two-dimensional formula. Treat the large error from putting the current dimension-100 fit back on two coordinates as a fitting problem of the high-dimensional optimizer. Add this fitted-constant lift to the node-replication method and fit Schrodinger and other mean-cosine trees again.",
      "B": "Goal: Decide how to lift a two-dimensional mean-cosine formula to high dimension, and how to treat the current Schrodinger result.\n\nPlan: Replicate cosine on every coordinate and combine the terms with a fixed factor of one over the number of coordinates. Write the high-dimensional formula as the exponential of a fitted scale times the mean of cosine of a linear function of each coordinate. Remove Schrodinger from the lift-success list because putting the dimension-100 fit back on two coordinates produces a large error. Keep the inherited mean constant equal to the number of coordinates."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_049",
    "options": {
      "A": "Goal: Find out whether a random-structure symbolic regression baseline can recover the d=100 expressions for pairwise and the six non-Conservation families.\n\nPlan: Run a random-structure plus LBFGS baseline at d=100 on pairwise_x2x2, quartic_anchor_sum, helmholtz_separable, poisson_sumsq, sum_x4, cos_anchor_sum, and radial_quartic. Give each family 6000 finite trials. After all 6000 trials finish, record whether any trial reaches rel-L2 below 1e-3, and record the best rel-L2 and the best expression.",
      "B": "Goal: Find out whether a random-structure symbolic regression baseline can recover the d=100 expressions for pairwise and the six non-Conservation families.\n\nPlan: Run a random-structure plus LBFGS baseline at d=100 on pairwise_x2x2, quartic_anchor_sum, helmholtz_separable, poisson_sumsq, sum_x4, cos_anchor_sum, and radial_quartic. Stop a family when one trial reaches rel-L2 below 1e-3, or when 600 finite trials have no such hit. Then record whether any trial reached rel-L2 below 1e-3, and record the best rel-L2 and the best expression."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_050",
    "options": {
      "A": "Goal: Add high-dimensional test problems that raise particle count while the interaction form stays the same.\n\nPlan: Take the next problems from multi-particle interaction equations, including the Kuramoto model, opinion dynamics, and Cucker-Smale. For each equation, write the interaction at a small particle number with the present operators, and check that the same form extends when the particle count grows. Run a seed-0 lift from 4 particles to 32 or 64 particles on the Kuramoto model and on one other equation that this check accepts. Use the same data splits at both particle counts, and treat the coupling constants as learnable. Score the candidates on the particle vector field after the parameters are set.",
      "B": "Goal: Add high-dimensional test problems that raise spatial dimension while the PDE form stays the same.\n\nPlan: Take the next problems from a hidden list of spatial PDE families at dimension 100. Cover four transfer classes, and give each class some positive families and some negative families. Fit tree-conditioned candidates and a matched blind grammar on the same collocation points and with the same optimizer. Select each candidate with PDE residual and boundary conditions only. Record the candidate count and the core-second cost for every family."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_051",
    "options": {
      "A": "Goal: Measure whether a low-dimensional expression tree reduces exhaustive high-dimensional search cost on four transfer primitives.\n\nPlan: Run the leaf, replicate, pairwise, and block tree-information jobs with one positive family and one matched negative family in each of four primitive classes, five tree arms, and one fit seed. Fit all target, cross, random, and oracle candidates, and on the blind arm fit the target-overlap candidate and 16 candidates drawn by expression-tree size in each family with the inclusion probability of each draw recorded. Compare target and blind candidate counts from the full family lists, and estimate blind CPU time from the stratified runtimes.",
      "B": "Goal: Measure whether a low-dimensional expression tree reduces exhaustive high-dimensional search cost on four transfer primitives.\n\nPlan: Run the leaf, replicate, pairwise, and block tree-information jobs with 24 hidden families, five tree arms, and three fit seeds. Fit every high-dimensional candidate on the target, cross, random, blind, and oracle arms. After the four classes finish, compare matched target and blind totals for candidate count and CPU time."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_052",
    "options": {
      "A": "Goal: Recover a hidden leaf or pairwise source tree whose affine error is below 1e-3, then run transfer and matched fit-all for Claim K.\n\nPlan: Keep seed 0 and the four physics tests at 1e-3. Use the V44 fixed-tree refit, the 28800-action search, and the PDE-solver teacher as the current source attempts. If any class falls below 1e-3, copy that source into a full-layer transfer on the hidden target and then run the matched fit-all with no early stop. If every current source stays above 1e-3, open a new source search that changes tree depth, the operator set, the seed, or the hidden family, and then run the same transfer and fit-all.",
      "B": "Goal: Test overlapping domain decomposition and a WKB phase search on the frozen double-well Schrödinger equation, then lift a passing local tree to d=100.\n\nPlan: Keep the V26 target with a=1 and domain [-3,3]. Run two seed-0 low-dimensional arms that split the domain at x0=0. One arm searches the wavefunction on overlapping left and right subdomains and joins them with a partition of unity. The other arm searches a WKB or Riccati phase on the same split. Score candidates with PDE, boundary, and interface residuals before reading the true solution. If an arm meets the 1e-3 tests, copy its local expressions into a d=100 all-layer transfer and run matched scratch FEX, SIREN, and DD-PINN baselines."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_053",
    "options": {
      "A": "Goal: Find out how the eight-family tree ablation changes when each cell winner is chosen by PDE residual.\n\nPlan: Rerun Conservation and two families where true-tree and no-tree both already passed. Fit the same four arms and choose the cell winner with a normalized PDE residual and boundary score on one shared validation point set. Generation, fitting, and selection load only residual and boundary data. After selection, a separate evaluator computes analytic relative L2. Use five seeds and report how often the physics winner matches the truth winner.",
      "B": "Goal: Find out whether the current true-tree successes come from explicit symbolic bases or from neural residual corrections.\n\nPlan: Take the residual_lift winners already stored for Conservation, HJB, Helmholtz, and pairwise_x2x2. For each winner, evaluate the symbolic base alone, the residual network alone, and the hybrid, and record relative L2 and residual magnitude. Record a symbolic recovery when the base alone is below 1e-3, or when the residual is rewritten with allowed primitives and checked on held-out points. List hybrid numbers next to the base-only numbers. Save a per-candidate ledger with parameter counts and independent PDE and boundary metrics."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_054",
    "options": {
      "A": "Goal: Measure whether a pretrained PDE-conditioned controller reduces full-FEX search steps on hard and high-dimensional PDEs.\n\nPlan: Connect the reference FEX code so that Adam and BFGS coefficient optimization is in the search loop. Reproduce the v1 function-fitting pilot and the v2 Poisson residual pilot. In the same first round, run a paired full-FEX study on 1D nonlinear Schrodinger and a high-dimensional Poisson scout, with test trees held out by structure. Compare pretrained, scratch, and conditioned-random controllers on the same instances and the same seeds. Record step-to-threshold, final residual, and wall-clock. Put the hard-family paired run and the high-dimensional scout on the first-round list with the FEX wiring. If the high-dimensional scout cannot solve, record the root cause and keep 1D nonlinear Schrodinger as the hard target. Set the paper claim to a FEX foundation-model study of controller pretraining.",
      "B": "Goal: Measure whether a pretrained PDE-conditioned controller reduces full-FEX search steps on 1D Poisson and 1D Helmholtz.\n\nPlan: Connect the reference FEX code so that Adam and BFGS coefficient optimization is in the search loop. Reproduce the v1 function-fitting pilot and the v2 Poisson residual pilot. Then run a paired Stage 0 study on reverse-generated 1D Poisson and 1D Helmholtz, with test trees held out by structure. Compare pretrained, scratch, and conditioned-random controllers on the same PDEs and the same seeds. Record step-to-threshold, final residual, and wall-clock. If the pretrained arm does not improve median step-to-threshold on Poisson or Helmholtz, end the expansion to other PDE families. Start nonlinear Schrodinger and high-dimensional Poisson after this Stage 0 result. Set the paper claim to a transfer-boundary study on these two families."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_055",
    "options": {
      "A": "Goal: Choose a data strategy after the real-source bank stays at 44 verified instances, 32 templates, and 21 actions, below the gate of 280 verified instances, 160 templates, and 40 actions.\n\nPlan: Use a yield of about 0.57 verified packets per paper, measured on 14 method papers, to size the next data work. Then pick one of three data strategies. The first expands the current expression grammar and sets a new data gate near 100 verified instances, 60 templates, and 30 actions. The second keeps the current gate and searches for another high-density formula table, such as a digitized handbook. The third trains the controller on a synthetic PDE generator bank and uses real PDEs only for evaluation.",
      "B": "Goal: Fill the data gate of 280 verified instances, 160 templates, and 40 actions with exact solutions taken from real PDE papers and PDE benchmarks.\n\nPlan: Search arXiv and public PDE benchmarks for papers that state exact 1D and 2D solutions. Build a list of at least 200 papers, and put physics-informed neural network benchmark papers, analytical-solution surveys, and solver-comparison papers first. From the top of that list, extract the PDE, solution, domain, and initial or boundary conditions from about 50 papers, and check each packet with independent residual tests. Use these real packets for both pretraining and evaluation."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_056",
    "options": {
      "A": "Goal: Get paper 2509.07478 through formula checks with the current grammar.\n\nPlan: Repair the 2509 packet. Turn the piecewise cases into the quadratic formula that the grammar already has. Bind the self-similar ODE and the transformed conditions in one frame, and set xi_0 only from source evidence that applies to the original problem. Keep the grammar, the action set, and the residual limits unchanged. Record paper 2104.14561 as outside the present representation. Replay 2509 and report whether a new verified formula appears in the 15-paper set.",
      "B": "Goal: Get paper 2509.07478 and paper 2104.14561 through formula checks.\n\nPlan: Repair the 2509 packet. Turn the piecewise cases into the quadratic formula that the grammar already has. Bind the self-similar ODE and the transformed conditions in one frame, and set xi_0 only from source evidence that applies to the original problem. Add an exact infinite-series action for paper 2104.14561. First test that old verified formulas stay the same, that the series meets the current residual limits, and that a finite truncation is not treated as the source formula. If that test passes, put the action into the grammar and replay 2104."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_057",
    "options": {
      "A": "Goal: Collect real PDE training examples from new papers, then keep those examples that pass a residual check.\n\nPlan: Start with 3 to 5 new arXiv TeX files. Take equation sections and nearby text as input. Send those chunks to gpt-5.6-terra through codex exec, or to sonnet5 through claude -p, at medium effort, and ask for JSON with example name, PDE, solution, domain, and conditions, each with a source line. Ask GPT-5.5 how to write the prompt, and try a few prompt versions on this set. Keep an example when the residual of the extracted solution in the extracted equation is below 1e-6 in SymPy. If at least one paper yields a passing example, enlarge the paper set by a factor of two to five and repeat.",
      "B": "Goal: Collect real PDE training examples from new papers, then keep those examples that pass a residual check.\n\nPlan: Search up to 200 new arXiv papers that were not used in earlier labeled sets and download their TeX. Take equation environments and nearby text as input. Parse the PDE, solution, domain, and conditions with a TeX formula parser. Keep an example when the residual of the parsed solution in the parsed equation is below 1e-6. Keep the set if at least 8 examples from 8 paper clusters and 5 PDE families pass. Then run the DeepSeek production extractor on this set and require 100 percent field precision and at least 80 percent example recall. If those gates pass, extract from about 100 papers."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_058",
    "options": {
      "A": "Goal: Build a source-real equation database from real arXiv papers, then extract roles and grow the training set.\n\nPlan: Split the 1,694 readable sources into 1024 training sources, 512 evaluation sources, and 64 development sources, with no source in more than one split. Keep every rendered math span from the saved TeX of those papers. On development sources, write a role-and-link prompt that names each span and how spans connect, then run the same prompt on later sources with no prompt change. Keep a raw row when the model answers unknown or when the current compiler cannot represent the span. Leave out locally generated formulas and formulas made by reversing a candidate solution.",
      "B": "Goal: Classify real-source equations as natural or manufactured, then admit later training data with that classifier.\n\nPlan: Take the 4 development and 4 confirm natural examples from the latest per-example review and train a labeling policy that marks each example as natural or manufactured. On development data, accept the policy only if it passes the format and ontology checks and labels no manufactured example as natural. Then run the same prompt on the confirm examples and on four blind waves of the existing manufactured-solution control bank, with no prompt change between waves. After those tests pass, collect 60 and then 120 new real PDE sources and keep only examples that the policy labels natural. Keep manufactured examples out of training and evaluation."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_059",
    "options": {
      "A": "Goal: Collect enough complete PDE-and-solution examples by opening arXiv tutorials and lecture notes on PDEs, SDEs, mathematical physics methods, and general physics.\n\nPlan: Select the next sources from arXiv metadata only, and record the source IDs before any TeX download. Open 16 tutorial or lecture-note sources across those four topics, together with 8 ordinary research papers that match on category, year, and version era. Run the current v3 extractor on both groups, keep every rendered equation, and count complete PDE-and-solution links per opened source. Then open a new set of 64 tutorial or lecture-note sources and 32 matched ordinary papers and extract them the same way.",
      "B": "Goal: Collect enough complete PDE-and-solution examples by finishing extraction on the current 1,694 arXiv research papers and then opening more papers from the same source lists.\n\nPlan: Continue the current v3 extractor on the remaining train, eval, and reserve slices of these 1,694 arXiv research papers. Keep every rendered equation from those papers. After the last slice is complete, count strict train rows, templates, actions, and held-out executable targets against the gates of 200, 80, 40, and 200. If those counts are below the gates, open the next ordinary arXiv research papers in groups of 256 from the existing citation, venue, and repository lists and extract them with the current v3 extractor."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_060",
    "options": {
      "A": "Goal: Recover complete PDE, condition, and solution tuples from real arXiv papers for the FEX training bank.\n\nPlan: Cut every rendered math span from each paper with a rule-based TeX parser. Send each span to gpt-5.6-terra and ask whether that span is a governing PDE, a boundary or initial condition, or a solution, and which other spans it pairs with. On the 16 already opened papers, run Sonnet 5 over the same 181 equation spans without showing it the first model's labels, and report per-field precision and recall with exact span readback. Ask GPT-5.5 to critique one prompt revision. If that independent pass reaches precision 1.0 and recall of at least 0.80, apply the same per-span questions to 16 new tutorial and lecture papers.",
      "B": "Goal: Recover complete PDE, condition, and solution tuples from real arXiv papers for the FEX training bank.\n\nPlan: Send each paper's full TeX source to gpt-5.6-terra or Sonnet 5 in one call. Ask the model to list every PDE, domain and conditions, and solution tuple in a fixed schema, and to fill fields that the paper leaves incomplete. Ask GPT-5.5 to critique the prompt, then test that prompt on four already opened papers, and require each accepted field to cite exact source bytes. Keep model-completed fields out of the real train and eval banks. If tuple precision is 1.0 and recall is at least 0.80 on those four papers, apply the same prompt to 16 new tutorial and lecture papers whose identifiers are chosen from metadata before the TeX is read."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_061",
    "options": {
      "A": "Goal: Prepare the pretrained versus no-pretrain comparison by compiling more of the current real-source equations.\n\nPlan: Increase the allowed expression tree depth and operators so more of the equations that were already extracted can compile. Replay the current GitHub and arXiv banks through that compiler, keep the labels from the current extraction pipeline, and split train and evaluation by source repository. Start the pretrained versus no-pretrain comparison on this replayed bank when the split counts pass.",
      "B": "Goal: Prepare the pretrained versus no-pretrain comparison by collecting more real PDE examples.\n\nPlan: Collect more real PDEs from documented papers, tutorials, and code repositories until training and evaluation meet the existing row, repository, template, and action counts. Take each label from the written solution formula in the source, not from nearby prose. Start the pretrained versus no-pretrain comparison after that bank is in place."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_062",
    "options": {
      "A": "Goal: Calibrate the FEX search baseline on 11 real PDEs and then compare a pretrained controller with a same-architecture controller that has no pretraining.\n\nPlan: Run R89a on the 11 source-native PDEs with the same cells, seeds, threshold, and budgets, including 1000 and 2000 steps on the Adam 100, BFGS 100, and weight 10 arm. Read the next real sources from a preset source list. Append only rows whose labels come from the source formulas, and rerun the R89e train and evaluation gates on that bank. Build 64-dimensional features from the operator, the domain, and the conditions for every training row. Build executable packets of the original PDE, boundary conditions, and initial conditions for every evaluation row. Launch R89f when R89a, the new bank gate, and this feature and runtime bridge all pass. Compare pretrained FEX with the same architecture with no pretraining.",
      "B": "Goal: Calibrate the FEX search baseline on 11 real PDEs and then compare a pretrained controller with a same-architecture controller that has no pretraining.\n\nPlan: Run R89a on the 11 source-native PDEs with depth-4 trees, threshold 1e-3, and three seeds. Cross Adam 20 plus BFGS 20 with Adam 100 plus BFGS 100, and cross condition weight 100 with condition weight 10, at budgets 200 and 500. Extend the Adam 100, BFGS 100, and weight 10 arm to budgets 1000 and 2000. If that arm solves at least 3 of 11 PDEs at budget 500, stop the ladder at budget 500. Add real PDEs until the bank gains 7 extra strict rows and the train count of 40 and the evaluation count of 20 both pass. Use the 20-dimensional feature vectors from the R89d controller check as training inputs, and use the R89d runtime contract as evaluation packets. If the combined arm meets the solve gate and the bank counts pass, launch R89f as pretrained FEX versus the same architecture with no pretraining."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_063",
    "options": {
      "A": "Goal: Find out whether a pretrained real-source controller beats the same network with no pretraining on a 20-row held-out comparison after the depth-lock study and the training split.\n\nPlan: Complete the depth-6 versus depth-4-lock study with the same controller, seeds, objective, and optimizer. Save every proposal, the action probabilities, and the exact-tree refits under both masks. Complete the 27-row training versus evaluation split, and run the depth-6 64-dimensional check whose only arm difference is loading pretrained weights. Train on the frozen 46 training rows and 20 evaluation rows plus accepted training rows. Compare the pretrained controller with the same network with no pretraining on the 20 held-out rows, using source-native objectives and intervals grouped by source and PDE.",
      "B": "Goal: Find out whether the local runtime matches the authors' FEX example and whether real features predict source trees before a 20-row pretrained search comparison.\n\nPlan: Pin the authors' Finite-expression-method code at the reference revision. On one authors' example, run a short CPU trajectory in both codebases with the same topology, actions, collocation points, coefficient start, Adam and LBFGS settings, reward, and policy loss, and record every difference. Train a supervised model on training-only rows and 64-dimensional solution-independent features under a repository and template holdout. Score that model against an action-frequency baseline and a feature-shuffled baseline on cross-entropy, tree accuracy, top-k recall, and calibration. Start the 20-row pretrained search comparison only if the supervised model beats both baselines."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_064",
    "options": {
      "A": "Goal: Collect real-source PDE training records from documented external examples.\n\nPlan: Take the DeepXDE 1D Poisson problem on [-1, 1], with residual π² sin(πx) and solution sin(πx). Open the source file, copy the PDE and solution quotes with byte offsets, build depth-6 labels from the formula, compute 64-dimensional operator features, and run the training-record validator. Add the record to the training bank only after that check passes, and collect each later real-source PDE by the same steps.",
      "B": "Goal: Use the extracted source rows as the training set for the next controller tests.\n\nPlan: Take the 46 training rows and the 20 held-out rows from the latest source expansion, and the accepted pairs from the 27-row readjudication. Compute 64-dimensional features and depth-6 labels from these rows. Train the controller on this set and compare it with the exact same architecture that does not load the prior, on the same held-out PDEs."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_065",
    "options": {
      "A": "Goal: Instantiate depth2_rml controllers with hidden width 1 and collect the additional real templates that this topology needs before the next training run.\n\nPlan: Build new treatment and control controllers as depth2_rml networks with hidden width 1. Collect additional real templates until the bank holds at least 57,200 distinct occupied decisions, which needs at least 11,433 new templates if each template adds one tuple. Later training and learnability runs use only these new controllers.",
      "B": "Goal: Train a structural prior on the current official-representable rows and compare treatment against control on the four frozen real evaluation PDEs.\n\nPlan: Train three checkpoints for 200 epochs on the ten rows that compile under the current depth2_sub controller with hidden width 50. Save the matching pre-load twins as the controls. Then run each of the four frozen real PDEs with the registered full search budgets, three paired seeds, and source-native objectives."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_066",
    "options": {
      "A": "Goal: Give a G3 bridge from the restricted two-arm witness to the FEX Poisson controller on the full depth-2 action space.\n\nPlan: Write a bridge proposition that lists assumptions for percentile selection, inner coefficient fitting, and product-policy gradients. Enumerate all 2187 depth2_sub templates of the Poisson grammar. Run a 12-seed sweep of the product, jointnorm, and joint-tabular controllers on this full action space, and record collision probability and slot-gradient conflict. Then run a 10-seed reward-gap sweep on subsets of size 16 and 64 from the same grammar.",
      "B": "Goal: Give a four-gate discoverability theorem that applies to symbolic-regression search systems.\n\nPlan: Write a theorem on a search system given by a grammar, a sound rewrite relation, a policy, and a coefficient loss. Prove that class exposure, policy-gradient geometry, and coefficient feasibility can fail independently under stated conditions. Give constructive witnesses in this abstract setting. Then record how the existing FEX quotient recurrence, e-graph containment result, and two-arm G3 witness instantiate the theorem."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_067",
    "options": {
      "A": "Goal: Measure whether marginal-dominance forecasts match FEX controller search traces.\n\nPlan: Run the FEX controller on a Poisson target with the depth-two grammar, the operator set of each slot, residual reward, and coefficient fitting. Record slot probabilities, gradient norms, and the time to hit a good class. Score the reward table of that run with the original action counts, and compare the forecast with the recorded traces.",
      "B": "Goal: Measure how often the marginal-dominance corner conditions pass on stored FEX reward tables.\n\nPlan: Read the existing per-class FEX reward cache. Cut each reward table into slices that keep two actions per slot. Score every slice on MD0, MD1, MD2, and the corner linear program. Report the pass rate at each level, and write a mapping note that treats each expression-tree slot as a two-action product-softmax factor."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_068",
    "options": {
      "A": "Goal: State a class-exposure lower bound and a link from that bound to two-action policy-gradient geometry.\n\nPlan: Write a lower bound on the expected number of trials for a reward-blind sampler to hit a good quotient class. Add a tightness argument and extend the bound to non-uniform sampling. Write a result that relates this waiting time to the time of a policy-gradient model that uses two actions in each slot. Give a bound and a counterexample for the gap between that two-action model and a model with more actions in each slot.",
      "B": "Goal: Measure whether the FEX controller finds a good expression on a Poisson equation.\n\nPlan: Run the FEX controller with a multilayer perceptron and sequential tree generation on a Poisson equation. Use action sizes 9, 3, 9, and 9 at the four slots. Log logits, gradient norms, slot probabilities, and the time to hit a good quotient class. Compare that time with a blind sampler on the same classes, and compare the logged path with the two-action marginal-dominance predictions."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_069",
    "options": {
      "A": "Goal: Prove the class-exposure bound and the G2 to G3 bridge for the FEX depth-2 nine-operator grammar.\n\nPlan: Restore the G3 proof files that are missing from this branch. Mark the factored-bridge lemma as conditional. Use the blind-sampler formulas on this grammar, with 1539 classes, one good class, and expected discovery time 770, as the class-exposure theorem. Use a two-action product-softmax proxy to place this grammar in the regime where blind sampling is slow and policy-gradient geometry can still succeed. Record these FEX depth-2 numbers and the proxy placement as the Version 7 theorems.",
      "B": "Goal: Prove that discoverability factors into independent dimensions for any symbolic regression system that meets named conditions.\n\nPlan: Write a list of conditions X that a symbolic regression search system must satisfy. Prove that under those conditions, the gap from an expression existing to a controller finding it splits into independent dimensions, including quotient relevance, class exposure, policy-gradient geometry, and coefficient feasibility. Prove that none of these dimensions implies another. Give the FEX depth-2 grammar with nine operators and the 1539-class count as a numerical example of this statement."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_070",
    "options": {
      "A": "Goal: Test the frequency prior on the current single-frequency Helmholtz and convection-diffusion problems.\n\nPlan: Use a depth-two expression tree and two-dimensional single-frequency manufactured PDEs with uniform samples. Remove the true solution from the Gate 2 frequency check. Repeat the clean, decoy, contamination, and prior-width tests on the 7-pi Helmholtz, 8-pi Helmholtz, and two-dimensional convection-diffusion cases. Collect a full target-frequency probability trajectory on the convection-diffusion case.",
      "B": "Goal: Test the frequency prior on multi-frequency, nonlinear, and nonuniform PDEs.\n\nPlan: Raise the expression tree to depth three so a two-frequency Helmholtz problem can be written. First test whether a fixed two-frequency expression can reach low error, then run standard search and oracle-soft search on that problem. Run a nonlinear PDE whose solution spectrum and right-hand-side spectrum differ, and run an estimator test with nonuniform samples. Remove the true solution from the Gate 2 frequency check and use residual fitting on these runs."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_071",
    "options": {
      "A": "Goal: Measure the paired AIC gap at one large-n cell on the R35 prediction line.\n\nPlan: Run one cell at gap 0.18, n 4096, and noise 0.003, with 5 master seeds and 500 bootstrap replicates. Reuse the existing lambda overrides for this cell. Pool the paired absolute AIC difference across the 5 seeds and report the 90 percent interval. Compare that mean with the R35 power-law value 0.0272 at gap 0.18. Send the next workshop version after this cell is collected.",
      "B": "Goal: Send the next workshop version on the synthetic evidence that is already collected.\n\nPlan: Keep the 27-cell label-swap fallback table, the 51-cell finite-n sign record, and the R35 per-gap power-law fit as the main numbers. Report the stopped R39 and R41 partial chunks only as extra sign checks. Add deprecation notes at the closed-form theory section and at the real-data claim in the proposal. Then send this version for workshop review."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_072",
    "options": {
      "A": "Goal: Check the R35 power-law prediction with the gap=0.18 cell at n=4096 as a paired primary-versus-fallback test.\n\nPlan: Use the five-seed pooled mean absolute AIC delta of 0.0480, with a 90 percent CI from 0.0328 to 0.0680. Divide 0.0480 by the R35 prediction 0.0272 at n=10^4. Record a pass if the ratio is in [0.5, 2.0], and record a miss only if the mean is above 0.082. Write 0.0523 at n=1536, 0.0480 at n=4096, and 0.0272 at n=10^4 as a monotone decay chain. Use this n=4096 result as the paired check of the large-n floor.",
      "B": "Goal: Check the R35 power-law prediction with a gap=0.18 paired primary-versus-fallback test at n=1024, and read the n=4096 cell for primary excess.\n\nPlan: Use the five-seed pooled mean absolute AIC delta of 0.0480, with a 90 percent CI from 0.0328 to 0.0680. Read the five master-seed label-swap excess values on the n=4096 cell. If every seed is -1.0 with zero spread, report 0.0480 as the distance of primary excess from -1.0. Use the gap=0.18 cell at n=1024 with 25 master seeds as the paired primary-versus-fallback test of the R35 direction. Keep the n=4096 value 0.0480 as the primary excess at large n."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_073",
    "options": {
      "A": "Goal: Use the label-swap fallback as the main estimand and take finite-n magnitude from the R29, R34, and R42 cells.\n\nPlan: Keep the label-swap symmetrized fallback as the main estimand. Read finite-n magnitude from the existing R29 25-seed n=1024 paired-bootstrap interval, the R34 n=1536 point, and the R42 n=4096 point, all at gap 0.18. Use the R42 ratio to the R35 power-law prediction as the large-n check. Send the next review with no new cell.",
      "B": "Goal: Use the label-swap fallback as the main estimand and take finite-n magnitude from a new n=2048 paired cell.\n\nPlan: Keep the label-swap symmetrized fallback as the main estimand. Launch a gap=0.18 n=2048 cell with several master seeds. Measure the paired primary-versus-fallback difference on that cell and use it as the finite-n magnitude. Record the R42 n=4096 point as a large-n consistency check."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_074",
    "options": {
      "A": "Goal: Measure the paired primary and label-swap AIC delta at gap 0.18, sigma 0.003, and n=2048, then send Version 6.\n\nPlan: Aggregate the 500 R28 chunk files that already exist for this cell and 5 master seeds, using the same paired-bootstrap method as R29. Report the pooled mean of the absolute AIC delta, the 90 percent interval, the sign on all 5 seeds, and the ratio of that mean to the R35 power-law value at n=2048. Count a ratio between 0.67 and 1.5 as a pass. Put this cell on the finite-n chain between n=1536 and n=4096. Send Version 6 after the aggregate file is written.",
      "B": "Goal: Measure the paired primary and label-swap AIC delta at gap 0.40, sigma 0.10, and n=1024, then send Version 6.\n\nPlan: Launch a chunk pool for this cell with 5 master seeds and 500 bootstraps. Draw those master seeds from outside the seed lists used in R28, R29, R34, and R42. After the chunks finish, compute the pooled mean of the absolute AIC delta and the 90 percent interval with the same paired-bootstrap method as R29. Report the 5-seed sign and the share of chunks where the label-swap value sits at the bound. Add this cell to the finite-n evidence at gap 0.40. Send Version 6 after the pool manifest is written."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_075",
    "options": {
      "A": "Goal: Measure current methods on the hidden test by using the five daily Kaggle submissions.\n\nPlan: Turn methods that already run into competition notebooks, beginning with the public-checkpoint inference pipeline and other distinct baselines or variants. Submit five different notebooks or configs today, record the public score, private score, and rank for each, and keep filling the daily quota on following days while local training work continues.",
      "B": "Goal: Finish the local outer-fold baseline chain first, then begin hidden-test submissions.\n\nPlan: Continue the 50-epoch public-architecture retrain on outer fold 0 until it finishes. After that run, compare matched component changes and the sparse-supervision and temporal-association pilots on the same fold. After those local pilots are collected, start offline notebooks and hidden Kaggle submissions as the later generalization stage."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_076",
    "options": {
      "A": "Goal: Retrain the public TemporalUNet3D, Node Transformer, and ILP pipeline in five-epoch segments on the first embryo-held-out fold to obtain a matched public baseline.\n\nPlan: After the official data, metric, and embryo-fold contracts are in place, write a development split inside the training embryo and measure step time on two or three GPUs. Train the public architecture for five epochs, stop, and inspect loss, recall, node count, and sample plots. If loss is falling and recall is not near zero, resume from the checkpoint to 20 epochs, inspect again, and then resume toward 50, with each segment limited to 6 hours and a resume checkpoint.",
      "B": "Goal: Retrain the public TemporalUNet3D, Node Transformer, and ILP pipeline for 50 epochs on the first embryo-held-out fold to obtain a matched public baseline.\n\nPlan: After the official data, metric, and embryo-fold contracts are in place, run a short job on two samples that lasts at most 30 minutes, then train the public architecture from scratch for 50 epochs with seed 0 on one GPU. Treat this retrain as one job with a budget of 18 to 36 GPU hours. After all 50 epochs finish, cache the predicted nodes and edge scores, and then run the detector, association, and solver comparisons on that cache."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_077",
    "options": {
      "A": "Goal: Measure how synthetic root hubs and off-volume forks change the hidden Kaggle score with the rest of today's submission slots.\n\nPlan: Reuse the R3 kernel v3 prediction file and do not rerun detection or association. The two submissions already sent today are that file with a root hub and five forks placed outside the imaged volume. Fill the last three daily slots with the clean file, the same file with a root hub and zero forks, and the same file with a root hub and ten forks. Save each file hash and public score as the hidden-metric readout of those graph transforms.",
      "B": "Goal: Measure how different detectors and association settings change the hidden Kaggle score with the rest of today's submission slots.\n\nPlan: The two submissions already sent today used the R3 public checkpoint notebook. Fill the last three daily slots with the collected R2 DoG and Hungarian baseline, the R3 public checkpoint at a different detection threshold, and the R3 public checkpoint with a different motion gate. Write those three prediction files locally and compare their in-volume node and edge rows before sending them. Save each public score as the hidden-metric readout of that method."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_078",
    "options": {
      "A": "Goal: Measure the association quality of the clean public-architecture retrain and continue that training for five more epochs.\n\nPlan: Load the R7 epoch-2 checkpoint and run full predict, solve, and official evaluate on the 27 inner-dev samples to obtain edge Jaccard, official score, and division Jaccard. Resume from the epoch-5 checkpoint and train epochs 6 to 10 with the same 3-GPU configuration, and run the same full graph evaluation after every epoch. For the day's five Kaggle submissions, send the R7 epoch-2 checkpoint, the R7 epoch-5 checkpoint, an R3 edge-threshold variant, an R3 and R7 ensemble, and an R7 epoch-10 or non-maximum-suppression variant.",
      "B": "Goal: Reproduce the 0.913 and 0.914 public-notebook cluster and measure how much of that score comes from a clean inference pipeline.\n\nPlan: Freeze the exact source, inputs, and dependencies of the public notebooks that sit at 0.913 and 0.914 on the leaderboard. Run three matched Kaggle replays that differ in only one place: the exact clean no-hack notebook, one high-cluster notebook, and that same high-cluster notebook with negative-time or out-of-volume nodes turned off. Compare the visible submission files and the hidden scores of these arms with the current 0.877 public-weight chain."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_079",
    "options": {
      "A": "Goal: Continue self-training of the public architecture and use the next hidden submissions for the current 0.877 pipeline.\n\nPlan: Use the remaining daily Kaggle submissions on the R7 epoch-2 and epoch-5 checkpoints. Also submit detection-threshold and ensemble variants of the public TemporalUNet3D pipeline that scores 0.877 on the hidden test. Resume the R7 run from epoch 10 on the 27 validation samples from the held-out embryo, and train the next 5-epoch segment with three GPUs. After each epoch, compute official score, adjusted edge Jaccard, and division Jaccard. If those graph scores rise, continue R7 in later 5-epoch segments and then ablate association and ILP on fixed candidate nodes.",
      "B": "Goal: Reproduce the 0.913 public notebook method and evaluate it together with the current 0.877 pipeline on the official metric.\n\nPlan: Download the public notebooks and checkpoints that produce the 0.913 leaderboard group and the 0.877 leaderboard group. Keep their original source, weights, and post-process code. Replay the 0.913 notebook as published. Replay the 0.877 public checkpoint with the extra test-time and tracking steps taken from the 0.913 notebooks. Score both replays with the official metric on the 27 validation samples from the held-out embryo, and submit both replays to the hidden leaderboard. Record the finished R7 official scores as the self-trained reference on the same split."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_080",
    "options": {
      "A": "Goal: Measure whether the public checkpoint with TTA, ILP, and the extra post-processing steps reaches the 0.913 leaderboard cluster on hidden test.\n\nPlan: Build a Kaggle kernel that loads the public support-pack checkpoint and runs TTA, ILP, gap close, short-track filtering, and line-fit. Submit that kernel on the next hidden slot. Take a hidden score between 0.908 and 0.918 as a match to the 0.913 cluster from this checkpoint and this pipeline. Use the local public-checkpoint score of 0.918 on 27 validation samples as the expected range.",
      "B": "Goal: Locate the exact public notebook whose linked submission sits in the 0.912 to 0.914 leaderboard cluster.\n\nPlan: Search Kaggle discussion threads and saved historical kernel versions for a source whose linked submission score is in 0.912 to 0.914. Compare that source with the no-hack notebook that already scores 0.908. Record whether the extra points come from tracking post-processing or from a graph-augmentation step that changes the division Jaccard term. If the live kernel version does not match, recover the historical script version that owns a 0.912 or 0.914 receipt."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_081",
    "options": {
      "A": "Goal: Identify the public notebook method that scores 0.913 to 0.914 on the leaderboard and reproduce it on hidden data.\n\nPlan: Search the Kaggle discussion forum and public notebooks for kernels whose linked submissions score 0.913 or 0.914. Compare those kernels with the R10 source audit, which currently ties exact sources only to 0.908, 0.885, and 0.884. For a candidate in that score cluster, record the kernel version, the attached datasets, and the submission that is linked to that source. Write down the inference and post-processing steps in that notebook. Submit the same notebook on the hidden leaderboard.",
      "B": "Goal: Reach the 0.913 leaderboard cluster by training the current public checkpoint and the R7 run for more epochs.\n\nPlan: Fine-tune the public 50-epoch checkpoint for 5 epochs on the full training data from both embryos. Use detection weight 10, division weight 1, time window 2, and half of the public learning rate. Resume the R7 run from epoch 9 and train 10 more epochs at half learning rate. Score each new checkpoint on the local official metric. If a checkpoint scores above the local public result of 0.918, attach it to the current inference pipeline and submit it on the hidden leaderboard."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_082",
    "options": {
      "A": "Goal: Find how much of the 0.028 score gap to the 0.908 public fork comes from the motion-relink and safe-division kernels that are already built.\n\nPlan: Record the R22 public-notebook fork hidden score of 0.908 as the current public control. Treat the old 0.913 leaderboard group as gone after the division-metric patch. At the next daily hidden quota, submit the five visible-complete kernels R26, R29a, R29b, R29c, and R29d. After those hidden scores arrive, compute the score change of motion relink, safe division, their interaction, and the patched augment variants against R19a at 0.880. After that analysis, take a user choice among a new checkpoint, a new post-process, or an ensemble as the next C3 path.",
      "B": "Goal: Find how the public 0.913 score is produced, and test two owned single-factor changes on that control.\n\nPlan: Record the R22 public-notebook fork hidden score of 0.908. Also copy the public dual-seed plus frame-retention notebook that still reports 0.913 and has no active exploit primitive. On the same samples, TTA, thresholds, and evaluator, run three local arms that turn on single seed, then dual-seed blend, then the frame-retention guard. On the dual-seed control, run one arm that rescues primary-only candidates on low-retention frames when a neighbor frame supports them within 6.5 µm, and one arm that turns on DeepCenter safe-division veto at threshold 0.12. At the next daily hidden quota, submit the same five kernels R26, R29a, R29b, R29c, and R29d, and keep those scores for the motion-relink and safe-division analysis."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_083",
    "options": {
      "A": "Goal: Measure an anisotropic 3D U-Net, a windowed association Transformer, and an Ultrack cue tracker on one split and the official metric.\n\nPlan: Train an anisotropic 3D U-Net on sparse cell centers, infer nodes, and score the graph with the official metric. Train a windowed association Transformer on fixed candidate nodes, predict edges, and score the graph with the official metric. Fit intensity and DoG cues on the training movies, run Ultrack on the development movies, and score the graph with the official metric. Use the same four training movies and the same four development movies for all three methods. Write a legal submission file from each method after the first train and infer cycle.",
      "B": "Goal: Measure how PU losses and training scope change official scores on the TemporalUNet3D tracker.\n\nPlan: Keep the TemporalUNet3D detector, the Node Transformer, and the ILP graph solver. Split the training objective into BCE with fixed class weights, legacy weighted PU, standard uPU, and standard nnPU. On a short train from one fixed checkpoint, record the first update where the non-negative correction becomes active. Start all later runs from that same checkpoint. Train the full model and the association head only under each objective, on two embryos and two seeds. Score every run with the official metric and record the scores by training scope and by objective."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_084",
    "options": {
      "A": "Goal: Send five prepared hidden submissions at the start of the quota day.\n\nPlan: During the preceding day, build seven cores that differ from all past submissions. At 22:30Z, set a fill order that places any new U core, V-distance core, and X-flat core first if each can produce a legal test-format submission, then fills remaining slots from the knob variants margin050, edge_weight005, edge_weight030, edge_weight020, edge_threshold050, margin020, and edge052. After 00:00:30Z, submit five arms once each in that order under a single owner. Keep that order unchanged when the preceding day's public scores arrive. Collect five unique refs with one attempt each.",
      "B": "Goal: Send five hidden submissions at spaced decision times during the quota day.\n\nPlan: Keep all five slots unused from 00:00Z to 06:00Z. At 06:00Z, 12:00Z, 18:00Z, 21:00Z, and 23:15Z, send at most one new arm after reading the latest local and public scores. Leave unused slots open for same-day U, V, and X results until 22:30Z. After 22:30Z, fill leftover slots from backups that have a closed local loop, a distinct prediction file, a passing test-format run, and a card that states the question, why the slot is used, and how the score will change the next choice."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_085",
    "options": {
      "A": "Goal: Set the next round of route experiments on the existing train4 and dev4 split.\n\nPlan: Run a new two-by-two on the 0.913 dual-seed Temporal U-Net and Node Transformer pipeline. The first factor uses dual-seed z-flip or primary-only z-flip. The second factor uses the learned post-processing or the geometry post-processing. Build new detections and new graph solves on the existing matched samples. Compare the combined cell with the current primary-only local score. Train the anisotropic 3D U-Net detector as its own named route on one GPU with this split and the official metric. Train the shifted-window detector as a second named route on the same GPU, split, and metric.",
      "B": "Goal: Set the next round of route experiments on the existing train4 and dev4 split.\n\nPlan: Run a traditional DoG and Hungarian calibration. Run an Ultrack solve that uses public image cues and no count prior. Open a Query Tracker association run on nodes that are already computed. Put a convolutional detector and a shifted-window detector in one group named U, and train them together as a same-device architecture and padding factorial. For the 0.913 dual-seed Temporal U-Net and Node Transformer pipeline, repair the daily submission controller and fill the missing primary-reflection and guard-off cell in the existing submission bank. Give T, U, X, and E each a successor run after the first batch."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_086",
    "options": {
      "A": "Goal: Test whether a voxel PU objective improves the anisotropic 3D U-Net over the dense control.\n\nPlan: Train the anisotropic 3D U-Net on all training videos with labelled-centre voxel positives, unlabeled samples from the train embryo grid, and three class-prior values, and train a dense control with the same host and seed. Keep checkpoints at 40, 120, 300, and 600 steps. For each objective, sweep threshold, peak spacing, and peak cap on the training videos, keep the selected setting, and then read the held-out embryo once.",
      "B": "Goal: Test whether a voxel PU objective improves the anisotropic 3D U-Net over the dense control.\n\nPlan: Train the anisotropic 3D U-Net with a voxel PU objective for 40 to 120 steps on three training videos, hold out the fourth training video, and compare it with a dense control on that held-out video. If official score and centre rank both beat the control, train all training videos and continue to 300 and 600 steps. Choose the operating point on the training videos and then read the held-out embryo once."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_087",
    "options": {
      "A": "Goal: Find the first source of the parent-score gap, and test whether legal binary nnPU beats same-host dense BCE on the anisotropic 3D U-Net.\n\nPlan: Run the parent identity comparison on all 54 matched samples in one launch. At the same time, train four U-Net runs on the current train split: dense BCE and legal binary nnPU at half, full, and double the recorded class prior, with checkpoints at 40, 120, 300, and 600 steps. When every run has finished, sweep threshold, NMS, and peak cap on train, then read the held-out dev split once.",
      "B": "Goal: Find the first source of the parent-score gap, and test whether legal binary nnPU beats same-host dense BCE on the anisotropic 3D U-Net.\n\nPlan: First compare parent identity on two samples, one from each embryo, and train one legal nnPU run plus one dense BCE run for 40 and 120 steps on one train fold. Read official score, labelled-center rank, and the positive-class share of risk. Expand the parent check to all 54 samples only if the two-sample identity run recovers the parent score. Expand nnPU to the half, full, and double prior grid and to 300 and 600 steps only if the short reading shows a visible positive-class term and beats dense BCE on rank and official score. Then choose the operating point on train and read the held-out dev split once."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_088",
    "options": {
      "A": "Goal: Continue the 0.913 system, the traditional detector, and the U-Net as three routes, and split the daily Kaggle slots across those routes.\n\nPlan: Measure the reverse-weight surface of the 0.913 system on matched54, and run a division diagnosis on those same graphs. Run the next traditional and U-Net tests as their own routes after the local scores that used only 44b6 samples. Submit each improved traditional and U-Net configuration for a first Kaggle test score. Use three of the five daily Kaggle slots on non-mainline routes and two slots on the current highest-score mainline.",
      "B": "Goal: Open a division route on the 0.913 system and spend the remaining Kaggle slots on 0.913 variants.\n\nPlan: Classify why the 0.913 graphs miss most ground-truth divisions. Sweep the geometric division gate on matched54. Also run the reverse-weight surface on matched54. Take one 6bba development read on the traditional detector and one on the U-Net. Assign the two remaining Kaggle slots to a harmonic-weight arm and a division-off arm of the 0.913 system."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_089",
    "options": {
      "A": "Goal: Choose the next T and V hidden packages from the notebook driver code in the repository.\n\nPlan: For T, use a package that retries a failed sample with a per-frame threshold, then skips that sample and writes the rows that finished. For V, copy that same per-sample skip and partial write into the V notebook driver, which already accepts a sample list. Register each package from these driver edits and spend the next T hidden slot and the next V hidden slot on those packages.",
      "B": "Goal: Choose the next T and V hidden packages from the exception in the Kaggle hidden rerun log.\n\nPlan: Open the Kaggle kernel pages for R55t and R55v and read the hidden rerun log. The Kaggle command-line tool does not return this log. Use the exception class and the error text from that log to choose the next edit in the T notebook and the next edit in the V notebook. Spend the next T hidden slot and the next V hidden slot after that log has been read and each edit has been matched to the exception."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_090",
    "options": {
      "A": "Goal: Raise the current 0.913 Kaggle score by testing association changes and by getting official readings on the U and V routes.\n\nPlan: Submit a copy of the public 0.915 and 0.916 notebook with no parameter change. On that parent, test local ranker on and off with three-frame lookahead on and off, and test the public harmonic-association method on and off. For U, measure predicted nodes over the GEFF estimate on each video and set a train-only per-movie node budget, then read the official score on the report videos. For V, collect the pending hidden outcome and choose the next arm from that reading.",
      "B": "Goal: Complete the local cost ledger, receipts, file inventories, hashes, and owner account for this round.\n\nPlan: Assign tasks that bind each run cost to a commit and write ledger lines from receipts. Add checks that evidence files and compact inventories stay in sync. Finish the owner listing fields, the count-scan coverage check, the round-end receipt, and the match between online submission refs and the owner account. If a receipt field, hash, or account line is missing, assign another task to fill it before a new scoring experiment starts."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_091",
    "options": {
      "A": "Goal: Measure the official score of an anisotropic 3D U-Net with channels 32, 64, and 128 against the traditional LoG detector.\n\nPlan: Train the U-Net on the two-embryo holdout splits, with each embryo held out in turn. Run training in segments of at most 5.5 hours and save checkpoints at 2k, 5k, 10k, and 20k updates. Continue while the held-out embryo score still rises. Score the traditional LoG detector on the same movies and the same metric. Register a Kaggle card when the pooled score and both embryo scores, official and raw, all exceed the LoG scores.",
      "B": "Goal: Measure the official score of the 600-step U-Net nodes under min-cost flow and Hungarian matching.\n\nPlan: Keep the 600-step U-Net nodes with channels 8, 16, and 32, and keep their scores and node counts fixed. Score those nodes with Hungarian matching. Score the same nodes with two min-cost-flow backends, one with out-degree one and one with out-degree two. Set any division parameters on the train embryo only. Register a Kaggle card when an arm raises official score and raw edge on both embryos."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_092",
    "options": {
      "A": "Goal: Train a U-Net detector that has higher official and raw-edge scores than the traditional detector on the same local split.\n\nPlan: Train an anisotropic 3D U-Net with channels 32, 64, and 128. Train on one embryo and score on the other, then swap the two embryos. Use dense BCE and learning rate 3e-4. Save the model and optimizer every 5.5 hours and keep training from those checkpoints until inner-dev official stops improving for two segments in a row. Score official and raw-edge on both embryos with the same association method used for the traditional detector. Build and submit a Kaggle package when U official and raw-edge scores are higher than that traditional detector on the pooled set and on each embryo.",
      "B": "Goal: Test whether a linker that can make cell-division forks raises the official score of the current U-Net nodes.\n\nPlan: Use the detections from the existing 600-update U-Net with channels 8, 16, and 32 as a fixed node set. Score those nodes with the current Hungarian matcher and with a min-cost flow that can give a parent two children. Choose the flow division radius and extra cost on the train embryo only. Report official, raw-edge, and division scores on both embryos. If the flow arm passes the local official and raw-edge gates on both embryos, pack those graphs and submit them as the U Kaggle entry."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_093",
    "options": {
      "A": "Goal: Find out whether an ILP division-topology change is still present in the graph that the official metric scores.\n\nPlan: On a few videos, lower the division weight so the solver emits extra daughter edges. Compare the solver graph, the graph after motion relink, and the final scored graph, and record whether those extra edges are present in the scored output. Keep the detector and ordinary edges the same. If the extra edges are absent from the scored graph, locate the stage that replaces the solver edges. If they are present, run a middle-weight probe on those videos, and go to all 54 matched videos when division true positives and raw edge both rise.",
      "B": "Goal: Find out whether a training-domain ILP division weight can raise scored division true positives on the public parent and the self parent.\n\nPlan: On two videos, lower the division weight and confirm that the solver can emit forks and that a multi-child drop filter does not remove them. Then build division weights from second-daughter edge scores on the training embryo, and add the shipped weight and a zero-weight control. Keep the detector, ordinary edges, and motion relink the same. Run this set of weights on all 54 matched videos for the public parent and for the self parent. If a middle weight raises division true positives on both embryos, keep that weight as a hidden-submission candidate."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_094",
    "options": {
      "A": "Goal: Get official and raw scores for the two mainline single-factor cards on the four visible samples that have local ground truth.\n\nPlan: Score the existing parent, secondary-source-off, and primary-retain-off outputs against the four local train ground-truth files with the official evaluator. Record official, raw edge, node adjustment, and division for each sample and both embryos. Read an official rise with no raw fall and no embryo conflict as a quality gain, and read an official rise that comes only from the node multiplier as a node-count effect.",
      "B": "Goal: Get private-leaderboard scores for the two mainline single-factor cards on the public .916 parent.\n\nPlan: Place the secondary-source-off card and the primary-retain-off card on today's two mainline private-leaderboard slots. These cards replay the exact .916 parent, change the final graphs on both embryos, and pass the submission eligibility checks. Use the private-leaderboard score as the official and raw reading for each card. Read a higher, equal, or lower private score as the removed factor being harmful, unnecessary, or helpful."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_095",
    "options": {
      "A": "Goal: Judge the size of the new R79 improvements and choose which interventions to turn into visible packages.\n\nPlan: Read the official scores of the mainline restore runs and the U-Net Hungarian gate-7 run on the same 54 samples. For add-only, re-parent-only, joint restore, and gate-7, record the official-score lifts +0.004831, +0.022225, +0.028112, and +0.008358 against their own controls. For the same four runs, record the error-rate reduction as each lift divided by one minus the control official score on those samples. Use the error-rate reduction as the measure of improvement size. Build a visible package for each mainline single action that is positive on both embryos.",
      "B": "Goal: Judge the size of the new R79 improvements and choose which interventions to turn into visible packages.\n\nPlan: Read the official scores of the mainline restore runs and the U-Net Hungarian gate-7 run on the same 54 samples. For add-only, re-parent-only, joint restore, and gate-7, record the official-score lifts +0.004831, +0.022225, +0.028112, and +0.008358 against their own controls. Use these official-score lifts as the measure of improvement size, and place gate-7's +0.008358 and add-only's +0.004831 on that same absolute scale when you rank size. Build a visible package for each mainline single action that is positive on both embryos."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_096",
    "options": {
      "A": "Goal: Choose the next particle-filter experiment from the hidden score of the 500-particle 192-seed config.\n\nPlan: After the daily quota reset, submit five notebooks: the 500-particle 192-seed particle-filter config, the full-data GBDT stack, a selector warmup blend, a selector smooth variant, and a 500-particle 256-seed or two-config ensemble. Begin the remaining four folds of the 500-particle 192-seed config only if that hidden score is below 8.582. If the hidden score is 8.582 or worse, record a negative config result and then run a well-level failure analysis on the saved fold-0 predictions. Keep other local particle-filter studies off until the hidden score is known.",
      "B": "Goal: Collect new local particle-filter evidence on the same day as the five hidden-score submissions.\n\nPlan: After the daily quota reset, submit five notebooks from the current particle-filter assets, including the 500-particle 192-seed config, the GBDT stack, selector variants, and a two-config ensemble. Begin the remaining four folds of the 500-particle 192-seed config on local CPU, together with the 256-particle 64-seed aggressive config. Run the well-level error analysis on the saved fold-0 particle-filter predictions, grouping wells by particle spread, well length, and GR gaps. Test a well-wise mix of the two profiles using an out-of-fold threshold on particle spread."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_097",
    "options": {
      "A": "Goal: Score the current particle-filter and GBDT candidates on the current leaderboard, and start the next local runs after those scores are known.\n\nPlan: Package five Kaggle submissions: the 500-particle 192-seed particle filter, the full-data GBDT stack, the selector warmup variant, the selector smooth variant, and a 500-particle 256-seed or two-config mix. Submit them after the daily quota resets, then wait for the scores. If the 500-particle 192-seed leaderboard score is below 8.582 ft, run the remaining grouped validation folds of that config. If that score is 8.582 ft or higher, record a negative result and then run a well-level failure analysis to choose a new direction.",
      "B": "Goal: Score the current particle-filter and GBDT candidates on the current leaderboard, and start the next local runs before those scores are known.\n\nPlan: Package five Kaggle submissions: the 500-particle 192-seed particle filter, the full-data GBDT stack, the selector warmup variant, the selector smooth variant, and a 500-particle 256-seed or two-config mix. Submit them after the daily quota resets. At the same time, run the remaining grouped validation folds of the 500-particle 192-seed config and the 256-particle 64-seed config. Also run a well-level error analysis on the predictions that already exist, and use those failure modes to design the next particle-filter config mix."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_098",
    "options": {
      "A": "Goal: Measure whether F-Path-CFM and A-Track-Pointer beat the particle-filter selector on sealed fold 0.\n\nPlan: Train each method with seeds 20260724, 20260725, and 20260726 using the same inputs, fold split, and compute budget. Compare each method with a matched deterministic control and with the R2 selector on pooled RMSE, signature bootstrap intervals, and catastrophic-well rate. If a gate fails, save reconstruction, rollout, and coverage diagnostics and repeat the same recipe on the same fold.",
      "B": "Goal: Move the hidden leaderboard score by expanding the current particle-filter profiles across all five typewell-group folds.\n\nPlan: Run the 500-particle 192-seed standard profile and the 256-particle 64-seed aggressive profile on folds 1 to 4, and form a 0.5/0.5 mean with the existing fold-0 files. On fold 0, assign each well one of those two profiles by an R2 particle-std threshold that is fit on folds 1 to 4. Collect public high-rank notebooks and discussion posts and turn unused particle-filter or stacking ideas into the next submission files."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_099",
    "options": {
      "A": "Goal: Test a whole-well two-dimensional alignment model on fold 0 as the next attempt to move about 2000 leaderboard ranks.\n\nPlan: On fold 0 of the signature split, resample typewell GR, lateral GR, and trajectory into a two-dimensional heatmap and predict several path modes. Use the current selector as the comparison on the same wells. Score the selected mode and the average of the path modes with pooled RMSE, and add a GR shuffle control and a no-GR control. If fold 0 does not beat the selector by 0.20 ft, stop further work on this representation.",
      "B": "Goal: Test F-Path-CFM and A-Track-Pointer on sealed fold 0 as the next attempt to move about 2000 leaderboard ranks.\n\nPlan: On sealed fold 0, train F-Path-CFM on spline path residuals with conditional flow matching and endpoint error, and train A-Track-Pointer with typewell pointers, continuous offsets, and global re-anchoring. Use three seeds, matched deterministic controls, and the current selector on the same rows. Compare pooled RMSE with signature-cluster intervals, catastrophic-well rate, and boundary error. If a pre-gate fails, localize that implementation and continue the other route."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_100",
    "options": {
      "A": "Goal: Test whether jointly training the Rep-Translator and the shared LoRA can produce a K>1 depth gain.\n\nPlan: Use the finished four-interface translator-only warm-up, where LoRA stayed at zero, as the no-LoRA Rep-Translator experiment. Next, on the existing FineWeb warmup data, train the Rep-Translator and the shared LoRA together with a K mix of 1, 2, and 4. Put the KL preservation term only on K=1 batches. Score held-out NLL at K values 1, 2, 3, 4, 6, and 8, and compare that curve with the frozen-LoRA warm-up. After this joint pilot, run a Rep-Translator-only ablation in the later attribution stage.",
      "B": "Goal: Test whether a no-LoRA Rep-Translator can translate Recurrent Block states so that K=1 and K=2 language loss stay close.\n\nPlan: Train only the Interface-I Rep-Translator, with no LoRA modules and with all pretrained Qwen weights frozen. Compare the K=1 path of prelude, Recurrent Block, then coda with the K=2 path that inserts the translator between two Recurrent Block passes. Train that K=2 path with next-token loss only, with no KL term toward the K=1 distribution and no skip that copies the entry state. On a held-out set, record whether K=2 NLL stays close to K=1 NLL, and whether the translated state differs from the entry state."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_101",
    "options": {
      "A": "Goal: Test whether a representation translator with no LoRA can map loop-exit states back to usable loop-entry states.\n\nPlan: Train only the Interface-I representation translator and add no LoRA modules. Keep every pretrained Qwen parameter frozen. Compare the K=1 path P then R then C with the K=2 path P then R then translator then R then C. Train with next-token loss at K=2 only, with no KL term toward the K=1 base output and no identity skip. On held-out data, measure next-token loss at K=1 and K=2. The pass condition is that K=2 stays close to K=1 and the translator output is not the entry state.",
      "B": "Goal: Test whether training the representation translator together with shared recurrent LoRA produces a real depth gain at K>1.\n\nPlan: Train the translator and the shared LoRA together on all four recurrence interfaces. Include a K=1 LoRA control and a direct-repeat control with no translator. First run a small overfit check on a fixed batch. Then run the joint training on the planned 20K nested supervised set. On held-out data, measure next-token loss at K=1, K=2, and K=4. The pass condition is that K=2 beats K=1 and K=4 improves further on K=2."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_102",
    "options": {
      "A": "Goal: Build the SFT pilot with a SWE slice of 2,000 unique issue groups.\n\nPlan: Add a second source of SWE trajectories and keep the example length at 8192 tokens. Draw 2,000 unique issue groups from the combined sources. Build the 20,000-example pilot from 9,000 Math groups, 5,000 Science groups, 4,000 Instruction groups, and these 2,000 SWE groups. Keep 2,000 SWE groups in the later subsets that use 36,000 Math groups, 20,000 Science groups, and 16,000 Instruction groups.",
      "B": "Goal: Build the SFT pilot with a SWE slice of 973 unique issue groups.\n\nPlan: Keep the example length at 8192 tokens. Use the 973 unique SWE issue groups from the current source. Build the 18,973-example pilot from 9,000 Math groups, 5,000 Science groups, 4,000 Instruction groups, and these 973 SWE groups. Keep 973 SWE groups in the later subsets that use 36,000 Math groups, 20,000 Science groups, and 16,000 Instruction groups."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_103",
    "options": {
      "A": "Goal: Jointly train Rep-Translator and shared LoRA on the four interfaces after the translator-only warm-up.\n\nPlan: Start each interface from its translator-only warm-up endpoint and insert a new shared LoRA with zero output. Train Rep-Translator and LoRA together for the full joint token budget. Use the same learning rate for both parameter groups on every joint step. Run this joint training on all four interfaces with the same token budget.",
      "B": "Goal: Train Rep-Translator and shared LoRA in two-step and three-step schedules on the four interfaces after the translator-only warm-up.\n\nPlan: Start each interface from its translator-only warm-up endpoint and insert a new shared LoRA with zero output. Train both modules together with a lower learning rate on the translator. In a three-step schedule, first train only LoRA with the translator weights at the warm-up values, then train both together with a lower learning rate on the translator. Use the same joint token budget on all four interfaces."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_104",
    "options": {
      "A": "Goal: Find out whether extra loop depth raises scores on the development and preservation benchmarks for the two-step routes.\n\nPlan: Send one real sample from each registered benchmark through tokenize, forward, and score. If a required field is missing, or if the scores are all zero, all null, or all the same, the full panel stays unstarted. Measure items per second, report the wall-clock time, and score all options and all K values in one forward pass. Then run the II-twostep, IV-twostep, and I-twostep checkpoints taken at 25 percent and 100 percent of joint training with K = 1, 2, 3, 4, 6, and 8.",
      "B": "Goal: Find out whether extra loop depth raises scores on the development and preservation benchmarks for the two-step routes.\n\nPlan: Run the full panel on the II-twostep, IV-twostep, and I-twostep checkpoints taken at 25 percent and 100 percent of joint training. Use every registered development and preservation benchmark, and for each question evaluate K = 1, 2, 3, 4, 6, and 8. Walk through the items in order and give each answer option its own forward pass at each K. Write per-item scores, option NLL values, and family macros from this run."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_105",
    "options": {
      "A": "Goal: Repair the panel scorer and then test one candidate on a small real-task set for a positive depth effect.\n\nPlan: Correct the multiple-choice option span and replace the IFEval placeholder with the official verifier. Score one current candidate at K=1, 2, 4, and 8 on a small real-task subset that will not be used again for later confirmation. Run the full II, IV, and I panels on the 25 percent and 100 percent checkpoints only if that small set shows a positive depth effect.",
      "B": "Goal: Repair the panel scorer and then run the full real-task panels for the current training routes.\n\nPlan: Correct the multiple-choice option span and replace the IFEval placeholder with the official verifier. Score the Base model and the II checkpoint at K=1 and K=2 on all seven benchmarks to obtain chance, floor, and the smallest detectable K=1 versus K=2 difference. When those checks finish, run the full II, IV, and I panels at K=1, 2, 3, 4, 6, and 8 on the 25 percent and 100 percent checkpoints."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_106",
    "options": {
      "A": "Goal: Measure whether one depth candidate gains from extra recurrence steps on a small real-task split.\n\nPlan: Let the three G10 depth-horizon training arms finish, and select the candidate with a G10 adjacent-depth proxy gain. Score that candidate at K equals 1, 2, 4, and 8 on a small held-out real-task split. Record the class-balanced paired macro intervals for K2 minus K1, K4 minus K2, and K8 minus K4, and record each preservation axis. Start the II, IV, I, and control panel matrix after those adjacent-depth intervals lie above zero and no preservation axis has an interval that excludes zero in the worse direction.",
      "B": "Goal: Measure whether the II, IV, and I two-step routes beat K1 on the seven-benchmark development and preservation panel.\n\nPlan: Finish the remaining production-equivalence and throughput checks on the current scoring path. Then run II-twostep, IV-twostep, and I-twostep at K equals 1, 2, 3, 4, 6, and 8 on all seven development benchmarks and the preservation vector, using the joint 25 percent and 100 percent checkpoints. Keep the three G10 depth-horizon training arms running in parallel. Use these panel scores as the next evidence that extra recurrence depth helps on real tasks."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_107",
    "options": {
      "A": "Goal: Measure whether the current two-step routes beat K=1 on the full real-task panel.\n\nPlan: When the scoring instrument, provenance, and power gates pass, run the full II, IV, and I two-step panels. Score all development benchmarks and the preservation vector at K=1, 2, 3, 4, 6, and 8 for the joint_025 and joint_100 checkpoints. If a benchmark is still at an empirical floor or the paired minimum detectable effect is larger than the observed K=1 versus K=2 gap, set the official task prompt on a held-out calibration split, rerun the full Base versus II K=1 and K=2 power panel, and then start this same three-route matrix.",
      "B": "Goal: Measure whether one frozen candidate has a positive real-task depth signal on a disjoint pilot split.\n\nPlan: When the scoring path is correct, freeze one trained candidate and score it at K=1, 2, 4, and 8 on a real-task split that does not overlap prompt calibration. Compute paired class-balanced macros for K=2 versus K=1, K=4 versus K=2, and K=8 versus K=4, and report the preservation axes. Start the full II, IV, and I panel matrix if those adjacent-depth 95 percent confidence interval lower bounds are all greater than zero, the four class K=8 versus K=1 point estimates are all at least zero, and no preservation axis has a 95 percent confidence interval that excludes zero against the candidate."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_108",
    "options": {
      "A": "Goal: Test whether extra recurrence depth helps after one change to training support, loop input, or loss, then score one passing model on a small real-task set.\n\nPlan: Finish the three G10 schedule arms that share the same start point and data order. Start further arms that do not use each other's scores: one trains depths 1, 2, 3, 4, and 8, one gives the translator a signal for the current loop, and one adds a loss that compares only adjacent depths. Score every arm on the same 1,000-document proxy. Then choose a candidate and, if it passes the adjacent-depth gate, score it on the small real-task split that does not overlap prompt calibration.",
      "B": "Goal: Test whether extra recurrence depth helps after a change to the training loss, then score one passing model on a small real-task set.\n\nPlan: Finish the three G10 schedule arms that share the same start point and data order. If the replay arm and the equal-call deep-tail arm both fail the adjacent-depth gate on the 1,000-document proxy, start one follow-up arm that keeps the same start point, data, order, steps, and recurrent-block count and adds a next-token loss at every earlier depth. Wait for this follow-up arm to finish. Then choose a candidate from these runs and, if it passes the gate, score it on the small real-task split that does not overlap prompt calibration."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_109",
    "options": {
      "A": "Goal: Test whether a stronger loop-count input to the Translator can improve extra-loop next-token loss under the G20 depth-grid K schedule.\n\nPlan: Keep the G20 depth-grid schedule and train on K=1, 2, 3, 4, and 8 with the same step, token, and call counts as that arm. Add a fixed loop-count feature to the Translator input at 5 percent of state RMS and at 15 percent of state RMS. Train those two signal arms on the shared Interface II route. After training, score extra-loop gain with held-out next-token loss at K=4 versus K=2 and at K=8 versus K=4.",
      "B": "Goal: Test whether extra loops improve next-token loss when the Translator has no loop-count input and training uses only K=1, 2, and 4.\n\nPlan: Train only on K=1, 2, and 4 with a three-stage schedule. In the first 20 percent of training, sample K=1 and K=2. In the remaining stages, sample K=1, 2, and 4, and keep at least 25 percent of batches at K=1 in every stage. Give the Translator no current-loop or depth feature. After training, evaluate K=1, 2, 3, 4, 6, and 8, and read K=3, 6, and 8 as untrained depths."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_110",
    "options": {
      "A": "Goal: Record training and inference MFU on the formal G26b config and continue B3 and B4 from the existing checkpoints.\n\nPlan: Add effective FLOPs, timing windows, and MFU to the training and inference logs for the current B3 and B4 config. Run a short smoke that must show training MFU and inference MFU both above 60 percent. If the value is below 60 percent, change kernels or batching and run the smoke again. Then restart B3 from step 1766 and B4 from step 3163.",
      "B": "Goal: Continue the B3 and B4 curriculum control trainings from the existing checkpoints and add MFU logging after those runs complete.\n\nPlan: Restart B3 from step 1766 and B4 from step 3163 on the same host with the same data, curriculum, and optimizer. Keep the current step receipts that already log tokens per second and elapsed time. After these two arms finish, add MFU, effective FLOPs, and timing windows to the training and inference logs."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_111",
    "options": {
      "A": "Goal: Build a four-class real-task development set whose Base-K1 accuracy is about 50 percent.\n\nPlan: Score the current six benchmarks with Base K1 and no adapter. Select whole task, subject, and official-difficulty strata by their calibration accuracy. Mix those strata so that the four-class development mean is between 45 and 55 percent, the 95 percent interval covers 50 percent, and each class mean is between 40 and 60 percent. If the current strata miss those bands, add more same-class benchmarks from the proposal list and repeat the Base-K1 calibration. Keep 256 rows in each of qa, science, math, and code after the bands are met.",
      "B": "Goal: Build a four-class real-task development set that covers Base-K1 accuracies near 25 percent, 50 percent, and 75 percent.\n\nPlan: Collect published or similar Base accuracies for each candidate benchmark and use those figures to choose which tasks to score. Score Base K1 with no adapter and assign strata to the 25, 50, and 75 percent bands, with more rows in the 50 percent band. Remove tasks whose Base accuracy is near chance or near ceiling. If a class-by-band cell is empty, add same-class benchmarks or official difficulty splits and score those. Keep at least 1024 development rows after the three bands are filled."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_112",
    "options": {
      "A": "Goal: Count the finished G26 curriculum arms as comparison endpoints, then run the four-class real-task selector.\n\nPlan: Take the completed II-AdamW, II-Muon, state-hinge, B3, and B4 runs as the endpoints for this round. Apply the 60 percent MFU rule only to training jobs that start later. Score every endpoint at K = 1, 2, 3, 4, 6, and 8 on the four-class development set with forced-option multiple-choice scoring and the official generation graders. Freeze one candidate with the original adjacent-depth real-task gates.",
      "B": "Goal: Get training MFU and inference MFU above 60 percent on the formal configuration, then continue the real-task comparison.\n\nPlan: Write effective FLOP counts, timing intervals, and MFU into the training and inference logs. Profile the formal training shape at K = 1, 2, and 4 and the formal inference batches. Change kernels, batching, or compile settings until both training MFU and inference MFU are above 60 percent on that configuration. Start new claim training and the five-endpoint real-task selector only after this MFU gate is met."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_113",
    "options": {
      "A": "Goal: Decide how the 30 percent MFU gate applies to multi-GPU training and mixed precision, and take the next training measurement.\n\nPlan: Judge the finished two-rank DDP job by each rank's own MFU, and require every rank to exceed 0.30. Use the BF16 dense peak as the denominator on the G33 precision ladder, including the FP32 L0 to L3 rungs. Score those existing receipts with this per-rank BF16-peak rule. On the BF16 formal recipe, measure stage and kernel time from A1 to T0 on the same card, implement one exact kernel change that preserves output, loss, gradient, and update, and remeasure K equals 1, 2, and 4 twice. Count a K as a pass only when its per-rank MFU is above 0.30 with the BF16 dense peak.",
      "B": "Goal: Decide how the 30 percent MFU gate applies to multi-GPU training and mixed precision, and take the next training measurement.\n\nPlan: Judge the finished two-rank DDP job by one aggregate MFU. Use the sum of parsed model FLOPs across ranks, one shared steady-state wall window, and the sum of each device's dense peak at the arithmetic dtype that ran. When a rung uses FP32, put the FP32 dense peak in that denominator. Score the DDP receipt and the G33 FP32 L0 to L3 rungs with this formula. Run the FP32 recipe on the formal reference checkpoint at K equals 1, 2, and 4, twice each, with the same output, loss, gradient, and update checks. Count a K as a pass only when its MFU is above 0.30 with the dense peak of the dtype that ran."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_114",
    "options": {
      "A": "Goal: Determine how to pass the 30 percent training and inference MFU requirement.\n\nPlan: Load the 2B and 4B formal models with the same recurrence and adapter layout used for 0.8B. Measure training MFU and inference MFU for both sizes, and record wall time and the semantic gates with each measurement. The 30 percent requirement is met if at least one of 0.8B, 2B, or 4B has both training MFU and inference MFU strictly above 0.30. Then choose the size with the shortest projected total training wall time, and run later development and science experiments on that size.",
      "B": "Goal: Determine how to pass the 30 percent training and inference MFU requirement.\n\nPlan: Work on the current 0.8B formal model. On training, measure the live BF16 path with the same output, loss, gradient, and update gates used for the FP32 candidate, and complete the skipped 32-step finite, resume, and held-out NLL trajectory. On inference, collect a new owned time profile after the fused decode change, and apply a joint-owner change only if every profiled cell has an MFU upper bound above 0.30. Start science runs only after this 0.8B candidate passes correctness, arithmetic, and the 0.30 MFU gate on both train and inference."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_115",
    "options": {
      "A": "Goal: Decide whether any of 0.8B, 2B, or 4B meets the training and inference MFU requirement, then choose the size with the shortest total training time.\n\nPlan: Restore a declared inference source path. For 0.8B, 2B, and 4B, collect training MFU and inference MFU at K=1, K=2, and K=4. For each of these six cells, choose one reasonable batch size by the shortest end-to-end wall on a fixed workload, then take MFU from two fresh runs at that batch size. A size passes when all six cells are above 30 percent MFU. Then choose the passing size with the shortest total training wall.",
      "B": "Goal: Decide whether any of 0.8B, 2B, or 4B meets the training and inference MFU requirement, then choose the size with the shortest total training time.\n\nPlan: Restore a declared inference source path. For 0.8B, 2B, and 4B, collect training MFU at K=1, K=2, and K=4, and collect inference MFU for MCQ, generation, and joint at batch 32 and at batch 64. A size passes when each training K and each inference segment at both batch sizes is above 30 percent MFU on two fresh runs. Then choose the passing size with the shortest total training wall."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_116",
    "options": {
      "A": "Goal: Decide how the 30 percent MFU code gate is tested on the 0.8B, 2B, and 4B models after G40.\n\nPlan: Restore source authority for inference, then measure six cells on each of 0.8B, 2B, and 4B: training and inference at K=1, 2, and 4. For each cell, choose one batch size that minimizes total wall time on a fixed workload, and score MFU on that batch size. A model passes when all six cells exceed 30 percent MFU. If more than one model passes, select the model with the shortest total training time. If no model passes, locate the failing cell.",
      "B": "Goal: Decide how the 30 percent MFU code gate is tested on the 0.8B, 2B, and 4B models after G40.\n\nPlan: Use the G40 result of zero passing sizes as the current code-gate contract. For training, stay on 4B with sequence length 8192 and microbatch 1, attribute K=4 non-GEMM time, and apply one owner change so that K=1, 2, and 4 all exceed 30 percent MFU. For inference, restore source authority, replay the 4B K=2 run at batch 32, and require MCQ, generation, and joint MFU all to exceed 30 percent. Then run batch 64 and require every batch cell to exceed 30 percent. A size passes when training at all K and inference at all segments and batches exceed 30 percent."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_117",
    "options": {
      "A": "Goal: Test whether extra recurrence depth improves quality when training covers every depth from K=1 through K=8.\n\nPlan: Run two training arms that share one initialization, one data order, one token budget, and one Recurrent Block call budget. One arm samples K=1, K=2, and K=4. The other arm samples every integer K from 1 to 8. The Translator input contains no loop index. The training loss has no KL term that matches a K>1 output to the K=1 output. At each depth from 1 to 8, report adjacent NLL, real-task scores, and how well the Translator output serves as the next Recurrent Block input.",
      "B": "Goal: Test whether extra recurrence depth improves quality after training on K=1, K=2, and K=4.\n\nPlan: Train the Translator and the shared LoRA with the staged curriculum that samples only K=1, K=2, and K=4. Use the current next-token objective and the K=1 preservation term. After training, evaluate K=1, K=2, K=3, K=4, K=6, and K=8. Treat K=3, K=6, and K=8 as a check on depths that were not sampled in training. Report adjacent-depth NLL and real-task scores at each of these depths."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_118",
    "options": {
      "A": "Goal: Measure training and inference MFU for the 0.8B, 2B, and 4B models at K equals 1, 2, and 4 on a 16-update workload, and then score the six-cell MFU gate on those measurements.\n\nPlan: Keep the pinned Qwen3.5 Base checkpoints, BF16, sequence length 8192, and Interface II. For each model size and each of those K values, pick a candidate micro-batch size that fits in memory and change only gradient accumulation so that tokens and steps per update stay the same. Run 16 updates, stop after the registered steady timing window, and report MFU from two new processes on the training side and on the inference side. A model size passes if its six cells are all strictly above 0.30, and one passing size is enough for the code gate. Give each training-size run this 16-update workload and then exit.",
      "B": "Goal: Measure which micro-batch size gives the shortest full-curriculum training wall for the 0.8B, 2B, and 4B models at K equals 1, 2, and 4, and then score the six-cell MFU gate on those batch sizes.\n\nPlan: Keep the pinned Qwen3.5 Base checkpoints, BF16, sequence length 8192, and Interface II. For each model size and each of those K values, time candidate micro-batch sizes on the full curriculum of 3598 steps at K equals 1, 4386 steps at K equals 2, and 2544 steps at K equals 4. Change only gradient accumulation so that tokens and steps per update stay the same. Choose the batch size with the lowest complete-training total wall, then start two new processes at that batch size and report MFU together with the summed curriculum wall. Run the same full-workload batch search for inference. A model size passes if its six selected-batch cells are all strictly above 0.30. Give each training-size run a budget of 3 A800 hours."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_119",
    "options": {
      "A": "Goal: Set the training optimizer after the physical batch size is chosen.\n\nPlan: First choose the physical batch size that gives the shortest end-to-end wall time for a fixed workload. Then search learning rate, weight decay, and warmup on a small parallel screen. After warmup, use a linear decay or a cosine decay, and search the weight-decay timescale between 5 percent and 20 percent of the full training horizon. Set these values separately for each training stage and for each parameter group. Use the screen results to choose the next small batch of candidates.",
      "B": "Goal: Set the training optimizer after the physical batch size is chosen.\n\nPlan: First choose the physical batch size that gives the shortest end-to-end wall time for a fixed workload. Then set the LoRA learning rate to 2e-4 and set the translator learning rate from the uniform, two-step, and three-step ratios. Set weight decay to 0.01 and warmup to 32 steps. After warmup, hold the learning rate constant for the rest of the run. Use this weight decay, warmup, and constant schedule for every training stage."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_120",
    "options": {
      "A": "Goal: Set the experiment size to 4B from the six-cell 25 percent engineering pass and start the 4B 10,528-step matched-call quality pipeline.\n\nPlan: Write a versioned code-gate decision that sets selected size to 4B, because 4B is the only size whose twelve fresh train and inference cells all exceed 25 percent, and keep 0.8B and 2B out of the size contest because each already has a valid inference-gate failure. After provenance repair, a new 12-cell tiered real-task asset, and the 4B physical batch-size receipt are closed, run a stage and group hyperparameter batch on 4B. When that batch writes a selection receipt, start in the same round the two 10,528-step shallow-versus-deep matched arms and the B5 and B6 controls on 4B. The 10,528-step pair is a must-run in that same round once the hyperparameter receipt exists.",
      "B": "Goal: Choose the experiment size by total training time and collect a 64-step matched-call hyperparameter sample on that size.\n\nPlan: Write a versioned code-gate decision that records 4B as a passing size and sets selected experiment size to none. On the same A800 board, time 0.8B and 2B under the same training kernel across translator-only, LoRA-only, and joint stage profiles, and reuse the closed 4B physical batch-size receipts for the 4B profiles. Select the size with the shortest projected three-stage training wall, build the 12-cell tiered asset on that Base, then train four 64-step matched shallow and deep hyperparameter candidates. Collect their loss curves, adjacent NLL, and a 96-row development probe, and end the round when those four candidates are analyzed."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_121",
    "options": {
      "A": "Goal: Finish the real-task tier asset after the 0.8B Base-K1 calibration stopped at 8 of 12 cells.\n\nPlan: Keep 0.8B as the selected size, and keep the 25, 50, and 75 percent accuracy layers, the quotas, and the official metrics. Grade generations with the official LiveCodeBench stop and extract functions, and stop a panel when any benchmark group scores all zeros. Regrade or regenerate the LiveCodeBench and word-sorting groups. Add official CRUXEval, ASDiv, and SciBench sources on this 0.8B Base. Write the 12-cell asset after all 12 cells are filled. Start the four matched-depth micro-runs after that asset exists.",
      "B": "Goal: Finish the real-task tier asset after the 0.8B Base-K1 calibration stopped at 8 of 12 cells.\n\nPlan: Keep the current LiveCodeBench, MATH, and GPQA items. Score the same registered code, math, and science subset on the 2B Base with the same calibration plan and the same method that graded the 0.8B outputs, using about 1700 rows. If 2B fills the missing cells, set the selected experiment size to 2B and write the 12-cell asset. If 2B still misses cells, widen the accuracy layers on 0.8B or change the official tasks after that measurement, then write the asset. Start the four matched-depth micro-runs after that asset exists."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_122",
    "options": {
      "A": "Goal: Obtain the remaining 22x scale readout and the matched-call K=1 through K=8 curriculum readout.\n\nPlan: Continue the main H8/r48 joint training until it reaches 22 tokens per LoRA parameter. Continue the parameter-matched K1 training until it uses the same total input tokens as the main method. In the same step, train two matched-call arms from the existing LoRA-only checkpoint, one with Translator updates and one with Translator frozen, using the same steps, tokens, data order, and R-call budget, with training depths covering K=1 through K=8. After each finished endpoint is sealed, evaluate it on the registered 1,000-document held-out proxy and the 128-row MedMCQA development set.",
      "B": "Goal: Obtain the remaining 22x scale readout and the endpoint comparisons that depend on those checkpoints.\n\nPlan: Continue the main H8/r48 joint training until it reaches 22 tokens per LoRA parameter. Continue the parameter-matched K1 training until it uses the same total input tokens as the main method. After the main endpoint is sealed, evaluate that checkpoint on the registered 1,000-document held-out proxy and the 128-row MedMCQA development set. After the K1 endpoint is sealed, evaluate the K1 floor and the block-damped and layer-damped baselines on the same calls."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_123",
    "options": {
      "A": "Goal: Measure whether ordinary LoRA trained on official MedMCQA train data improves MedMCQA accuracy at 5 tokens per LoRA parameter.\n\nPlan: Build a train-only supervised set from the official MedMCQA train split. Put the gold option as the first target token, and keep every development and confirmation identity out of training. Train ordinary parameter-matched LoRA from the same base model on this set to 5 tokens per LoRA parameter, and score the same 1,280-row MedMCQA development set against the original Base model. If accuracy does not rise, change the training sources or replace the benchmark and run the ordinary LoRA check again. After ordinary LoRA improves on a pair of training data and benchmark, compare Looped LoRA with ordinary LoRA on that same pair.",
      "B": "Goal: Measure whether full-horizon Looped recurrence improves MedMCQA accuracy relative to K=1.\n\nPlan: Continue the deep-updated, deep-frozen, and shallow-frozen Looped arms from the existing joint256 checkpoints to the full 7,658-step horizon, with the same data order, token budget, and LoRA schedule. Evaluate the four cells at K=1 through K=8 on the current 1,280-row MedMCQA development set and the held-out proxy. Add damped Euler controls from the K=1 state of each deep endpoint. Keep paired item accuracy as the primary readout, and use the full-horizon results to decide the depth-gain claim and the next structure or scale change."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_124",
    "options": {
      "A": "Goal: Measure how close Muon-preprocessed training updates are to the Marchenko-Pastur spectrum, and collect published evidence for that claim.\n\nPlan: Use singular-value spectra taken only after SOAP, trust blend, and Schatten-4 scaling. Report a direct distance from those spectra to the Marchenko-Pastur law that matches the matrix shape. Write the distance rule and pass synthetic tests on known Marchenko-Pastur draws. Recompute that number on the existing seed 0, 2, and 3 spectrum files. At a few late checkpoints on two new seeds, hold the model and optimizer still, run several independent minibatches through the same preprocessing, average the spectral distributions from those batches, and then compute the distance by operator. Read papers on gradient spectra, random-matrix theory in neural training, and Muon, and record each source as direct theory, indirect observation, or counter-evidence.",
      "B": "Goal: Test whether the V3 Newton-Schulz schedule beats the exact 12-step schedule after each method uses its own muon learning rate and cautious weight decay.\n\nPlan: On seed 0, run Track 3 training from step 0 to 2900 on a 3 by 3 grid of muon learning rates 0.035625, 0.0375, and 0.039375 and cautious weight decay 0.020, 0.025, and 0.030. Launch 16 new runs, eight for the exact schedule and eight for V3, and reuse the two center cells from earlier clean runs. Keep the V3 coefficients the same on every cell. Watch all Newton-Schulz matrices and mark a cell failed if any singular value goes above 1.5. Inside each method, pick one complete safe cell from the late-loss tail on steps 2600 to 2750. Confirm the two chosen settings on unused seeds 3 and 4 with the same 2690-step paired-loss and safety gates."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_125",
    "options": {
      "A": "Goal: Study selected-feasibility failures on the finished 8-benchmark screen and one Williams coverage repair.\n\nPlan: Keep the completed 2304-cell screen as the main experiment. Report selected gaps together with the alpha-tightening and dose-response frontiers on those cells. Run one coverage repair on Williams-Otto with the symbolic surrogate, choose the repair from random coverage only, and record the new coverage, selected gap, and baseline cost. Treat that cell as a case study in a baseline-gated evaluation of selected feasibility.",
      "B": "Goal: Produce at least two valid hard cells under the current gates and test scale-aware selected-risk calibration on them.\n\nPlan: Repair Williams-Otto symbolic coverage by choosing training and calibration size from random coverage only, then remeasure the selected gap and the alpha-tightening, dose, and trust-region frontier. Run a stress suite that varies residual pocket width, amplitude, location, and boundary-biased objective risk, and report every grid cell. On cells that pass the current coverage, gap, violation, and cheap-baseline tests, run k-nearest-neighbor scale-aware selected-risk calibration and the same baseline frontier."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_126",
    "options": {
      "A": "Goal: Produce hard cells that can support a method-necessity claim under the 0.88 random-coverage threshold.\n\nPlan: Keep the 0.88 random-coverage threshold. On the Williams-Otto symbolic cell, choose one coverage repair from a pre-registered train and calibration grid using only random coverage, then measure selected gap, alpha-tightening, dose response, and kNN scale-aware calibration. In parallel, run a parameterized stress suite with spatially localized residual pockets and objective distributions that put mass on high-risk boundaries. Apply the same coverage, gap, violation, and cheap-baseline gates to every cell in that grid, and run kNN scale-aware selected-risk calibration on the cells that pass.",
      "B": "Goal: Recast the project as a baseline-gated evaluation of when optimizer selection breaks conformal constraint learning.\n\nPlan: Keep the 0.88 random-coverage threshold. Use the completed 2304-cell screen as the study sample, and report that alpha-tightening or a small dose margin closes large selected gaps at low cost. Keep the Williams-Otto symbolic cell as an exploratory case study. Choose one coverage repair on that cell from a pre-registered train and calibration grid using only random coverage, then measure selected gap and simple baselines. If the selected gap disappears after coverage rises, record that outcome as evidence that a stronger random certificate can replace selected-risk calibration."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_127",
    "options": {
      "A": "Goal: Find optimizer-selected feasibility failures on the eight existing benchmarks where cheap controls do not close the gap, and test selected-risk calibration and LLM-guided symbolic constraints as repairs.\n\nPlan: Repeat the eight-benchmark hard-cell screen with coverage_min of 0.88, selected gap of at least 0.08, static selected violation of at least 0.15, and cheap controls given by tighter alpha, dose penalties, and trust regions. Add residual-hotspot and boundary-pressure objective modes that push the solver toward high-residual and near-boundary points using only train and calibration data. On cells that pass all gates, and on the top selected-gap cells if none pass, run additive SRC and kNN scale-aware SRC with hyperparameters chosen on objective-cal data and a single held-out objective-test report. Generate LLM-guided symbolic constraint candidates for methane, Williams-Otto, and any new target cells, then evaluate them with the same selected-feasibility and cheap-control gates.",
      "B": "Goal: Find localized residual hard cells whose random coverage sits above 0.895, and test a boundary-conditioned residual-scale estimator on the remaining no-candidate cells.\n\nPlan: Join the R25 hard-cell list with the R29 calibration-only k and q choices and the R30 independent 5000-point coverage results, and keep cells that pass the coverage_min of 0.88 gate and the calibration-only selection rule. Generate a new localized residual suite around the successful families, using larger train and calibration sizes, independent n_random_test of 5000, boundary and interior-near-boundary locations, and the same alpha, dose, and trust controls. Keep the hard-cell gate at coverage_min of 0.88, and record which cells also reach coverage_min of 0.895 or 0.90. On the no-candidate and cost-borderline cells, train residual-scale estimators that use distance-to-boundary and local residual density from random-calibration data only, select the estimator on objective-cal UCB, and evaluate once on held-out objective-test data."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_128",
    "options": {
      "A": "Goal: Choose the next experiment after the Williams LLM-SR coverage rescue reported coverage min 0.8787.\n\nPlan: Keep the R40 expression, training split, and pinball tau fixed. For each of seeds 0, 1, and 2, draw a new calibration set of 1000 points and a new independent random test set of 20000 points. Measure coverage and selected gap again on the three objective modes with the same solver settings. Place the original seed-level coverage values, including the seed 0 interval around 0.8787, next to these locked measurements.",
      "B": "Goal: Choose the next experiment after the Williams LLM-SR coverage rescue reported coverage min 0.8787.\n\nPlan: Continue the R38 dense k and q sweep on the remaining selected-risk targets. Count a Williams LLM-SR cell as eligible only if coverage min is at least 0.88. With coverage min 0.8787, stop further Williams LLM-SR coverage work and keep the R40 expression, the calibration size of 300, and the current random test set unchanged. Wait until an R38 target has all three seeds with violation at most 0.10 and matched cost at most 5 percent."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_129",
    "options": {
      "A": "Goal: Find whether a non-Williams target in the R38 selected-risk repair passes the per-seed strict test on the targets that already have complete calibration.\n\nPlan: Take the R38 targets whose calibration checkpoints are already complete as the target set. Apply the calibration-only selection rule to this set. Then run a held-out test on new objectives for the selected configs and report the per-seed strict pass or fail results. If a later calibration of the unfinished oscillatory_box_4d targets yields a selected config, evaluate that config on a new held-out split.",
      "B": "Goal: Find whether a non-Williams target in the R38 selected-risk repair passes the per-seed strict test after every calibration target is complete.\n\nPlan: Continue the R38 dense k and q calibration sweep until all 18 targets have complete calibration checkpoints, including the two remaining oscillatory_box_4d targets. After all calibration checkpoints are complete, apply the calibration-only selection rule to the full 18-target set. Then run a held-out test on the selected configs and report the per-seed strict pass or fail results. Include the oscillatory_box_4d targets in this selected set once their calibration checkpoints exist."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_130",
    "options": {
      "A": "Goal: Decide the low-cost claim by comparing each selected row to the recorded 5 percent relative-cost rule.\n\nPlan: On the existing R41 objective IDs, keep the low-cost claim as a per-seed test that relative cost is at most 5 percent. Also compute paired absolute cost, cost divided by the decision-box objective range, and cost divided by the static P95 to P05 scale for the selected rows and the strong controls. On a new performance split, report the same cost quantities and the control frontier, and do not set a new success threshold. Record heteroscale seed 0 at 5.5098 percent as a miss of the 5 percent rule. If a new threshold is needed, wait for a human to write that number.",
      "B": "Goal: Decide the low-cost claim by reading the observed cost behavior on the existing R41 decisions.\n\nPlan: On the existing R41 objective IDs, recompute paired absolute cost, cost divided by the decision-box objective range, and cost divided by the static P95 to P05 scale for each selected row and each strong control. Read the origin-shift audit and the control frontier. Include the heteroscale seed 0 relative cost of 5.5098 percent and the 289 times that a constant objective shift changes the 5 percent label. State whether each selected row is cheap relative to the controls that meet the risk target on every seed. On a new performance split, report the same cost quantities and interpret them from the observed gaps. The 5 percent figure may be changed after this reading."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_131",
    "options": {
      "A": "Goal: Measure selected feasibility on the eight-benchmark matrix with the linear OCL solver, and test a constant floor that uses the same proposal queries as the learned envelope.\n\nPlan: Run the original eight benchmarks, three surrogates, six objective laws, and three seeds with the linear OCL solver, the 0.88 coverage gate, and the existing alpha, dose, and trust controls. On each new hard cell, fit a smooth max-affine correction on 300 proposal objectives per seed, certify the frozen rows on a new objective split, and draw a fresh frontier against static conformal and those controls. On the frozen methane and Williams contexts, give a constant-floor family the same 300 selected-point oracle queries per seed, freeze each seed at its lowest-cost safe strength, and certify the envelope and the floor on the six objective laws.",
      "B": "Goal: State a selected-risk mechanism on a two-region family, and test a positive-neighbor methane scale and a non-chemistry real-domain cell.\n\nPlan: Construct a two-region OCL family and name a deployment-cost interval where a location-dependent correction has selected risk at most alpha and every constant-margin policy has selected risk above alpha. On the locked R43 methane expression and the same training and calibration splits, score each point by the largest positive residual among its neighbors and by a density-weighted positive severity, and evaluate both scales on the same objectives, solver, and oracle queries as the kNN quantile and the two-part estimator. Rescreen portfolio3d with residual-hotspot and boundary-pressure objectives, and if that screen still has no hard cell, add one published non-chemistry OCL benchmark and run the same selected-feasibility and cheap-control measurements."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_132",
    "options": {
      "A": "Goal: Obtain a repaired 54-unit R68b solver matrix on the 200-objective sample set for every unit.\n\nPlan: Use the current 200-objective sample, with identifiers that are multiples of 5, as the matrix that each unit must complete. Finish the remaining sample shards so that all 54 units have a nested 20, 100, and 500 start result. On those rows, report method and control ordering, solver status, infeasible rows, optimal value, and nested ladder movement. Then report paired risk and cost intervals on this 200-objective 54-unit matrix.",
      "B": "Goal: Obtain a repaired 54-unit R68b solver matrix on the 1000-objective set for every cell.\n\nPlan: Use the current sample gate to choose cells for full replay, with nested ladder change as one of the triggers. The measured sample already sends 53 of 54 units and all 18 cells into that replay. On each selected cell, run the repaired nested 20, 100, and 500 start ladder at 1000 objectives with the same methods and controls. Then report paired risk and cost intervals on this 1000-objective 54-unit matrix."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_133",
    "options": {
      "A": "Goal: Measure the V8b deletion-help rates after prompt-level filters and build a multi-unit organic set with a ShareGPT chat-host arm.\n\nPlan: Re-aggregate the existing R32 Qwen and Mistral unit-outcome parquets with prompt-level sha256 dedup, a minimum of 3 sentence units per organic prompt, a prompt-level Y_noop band of 0.05 to 0.95, and source-proportion IPW. Report R_real, CF_math, and CF_chat on that filtered set with a per-source and per-multi-unit table. Write a coverage audit that records how many prompts remain after each filter step. Mine a fresh WildChat, ShareGPT, AgentIF, and CodeChat sample under the same dedup and multi-unit rules. Build a ShareGPT conversation-host chat anchor with middle, density-2, plain injection. Choose Branch A, B, or C from the filtered aggregate.",
      "B": "Goal: Report the V8b Branch B finding on the current organic backbone and send it to review.\n\nPlan: Use the collected R32 and R33 drop-regime aggregate as the paper headline. Keep the organic set as 425 prompts (420 MBPP, 2 WildChat SQL, and 3 filtered AgentIF) and keep the R28 HumanEval-host chat anchor. Report R_real = 0.074 with lower 90% CI above 0, CF_math = 0.266 with CI excluding 1, and CF_chat = 0.215 with P(CF_chat > CF_math) = 0.37. Write the paper claim as weak Claim 2 held and Claim 3 falsified. Record the MBPP-heavy mix, the n=2 WildChat SQL cell, and the two floor-bound AgentIF prompts in limitations. Send this STATE to review for NeurIPS Findings, and keep the R28 recipe and the drop and fill Pattern 7 check as supporting material."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_134",
    "options": {
      "A": "Goal: Produce the next V9 review package for the organic-prompt calibration study.\n\nPlan: Finish the R38 inference on the R34b-v2 set of 455 organic prompts. Use Qwen2.5-7B-Instruct and Mistral-7B-Instruct-v0.3 with the four intervention arms and six samples per unit. Then run R39 to merge the R34b set of 50 prompts with R34b-v2 into one combined set of at least 100 organic prompts. Send that combined package to the V9 reviewer after R39 completes.",
      "B": "Goal: Produce the next V9 review package for the organic-prompt calibration study.\n\nPlan: Send the R36 results on the R34b set of 50 organic prompts to the V9 reviewer. Use this package to obtain a review of the matched per-sentence protocol, the hygiene pipeline, and the CF_math claim. If that review reports a defect in method, code, or argument, fix the defect on this 50-prompt scale and send another review. Run the R34b-v2 inference on 455 organic prompts after a review that names experiment scale as the remaining issue."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_135",
    "options": {
      "A": "Goal: After the V12 not-ready review, run a V13 batch of three experiments over up to two days of wall time, then send one review, and keep the target venue as a choice among NeurIPS main, NeurIPS workshop, and stopping the project.\n\nPlan: Remine 30 fresh WildChat prompts and score Qwen2.5-7B-Instruct on delete versus no-op with two samples per unit, about 1200 forwards, to test whether the Qwen mean deletion effect on WildChat is below zero, above zero, or crosses zero. In the same dispatch, score 30 LMSYS hosts with the GSM-IC distractor under an objective verifier and a judge, with two samples per unit, to test whether the LMSYS mean effect matches the HumanEval host or the ShareGPT host. Also run LLMLingua-2 on the existing 50 organic prompts and compare ROC-AUC and precision at the 14.5 percent tail with random delete. After all three runs finish, send one V13 review.",
      "B": "Goal: After the V12 not-ready review, set the target venue to NeurIPS Datasets and Benchmarks, run one WildChat remine of at most one hour of wall time, and then send that result to review.\n\nPlan: Write NeurIPS Datasets and Benchmarks as the target venue in the idea, the proposal, and STATE. Remine 30 fresh WildChat prompts that do not overlap the current organic WildChat set. Score Qwen2.5-7B-Instruct on delete versus no-op with one sample per unit, using at most the three longest units in each prompt, for at most 180 forwards and at most one hour of wall time, and record whether the Qwen mean deletion effect is below zero, above zero, or crosses zero. If mining yields fewer than 30 WildChat prompts, switch the source to ShareGPT inside the same one-hour budget. When this run finishes, send the result to review and write the next experiment from that review."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_136",
    "options": {
      "A": "Goal: After the V14 review, wait for the user to choose a project path before any V15 experiment.\n\nPlan: Do not start a V15 run and do not lock the next run protocol. Present four options to the user. One option is another one-hour V15 experiment. One option is a bundled cycle that tries to close at least three must-fixes, with a prompt-compression baseline, an organic re-run that uses the length-null arm, and a rewrite of STATE sections 1 to 6. One option is to send the current V14 paper to NeurIPS Datasets and Benchmarks and archive the workspace. One option is to rewrite the idea as an ICLR or EMNLP short paper. Wait for the user reply before any of these starts.",
      "B": "Goal: After the V14 review, run the next V15 experiment under the one-hour cadence.\n\nPlan: Re-aggregate the existing R34b drop-strict six-prompt headline subset. Compute A_real as delete minus length-null on the same-prompt-only matched units. Report paired prompt-cluster bootstrap 90 percent confidence intervals. Also report the same-prompt unit count and the cross-prompt fallback rate. If the parquet has no length-null arm, abort this run and write a six-prompt length-null GPU pilot for the next dispatch. After this run, send V15 to review."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_137",
    "options": {
      "A": "Goal: Close the Stage 0 closeout gaps reported by the latest audit.\n\nPlan: Update the closeout checker so the official receipt checker runs on every verdict-reachable run. Treat a missing or failing receipt as a blocker. For any dirty reachable run, require a receipt pass and a machine proof that the dirty files are not load-bearing before the run can stay as a warning. Bind each latest-audit issue to a predicate with the same meaning. Then recompute a Stage 0 closeout. Start the MuJoCo controller-versus-RL comparison only after that closeout reports no unresolved blocker, critical, or major findings.",
      "B": "Goal: Reproduce PPO on the Gymnasium MuJoCo v5 environments listed in the task cards.\n\nPlan: Use the six MuJoCo v5 task cards and the PPO sources they name from RL Baselines3 Zoo and CleanRL. First train a short PPO smoke on InvertedPendulum-v5 and Hopper-v5. Then train PPO on those six v5 environments with the published hyperparameters and several seeds. Record eval returns, learning curves, and the recipe source for each run. Compare the eval returns with the published v3 and v4 reference ranges stored on the cards."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_138",
    "options": {
      "A": "Goal: Close the Stage-0 audit findings that remain after the v25 closeout.\n\nPlan: Run a v26 strict closeout that treats a predicate source outside the evidence graph as a BLOCKER, registers the self-receipt file in the manifest, and resolves audit issues from the coverage, receipt, and graph reports. Keep MuJoCo PPO and SAC baseline training unstarted until this closeout reports zero BLOCKER, CRITICAL, and MAJOR findings.",
      "B": "Goal: Reproduce PPO on Gymnasium MuJoCo v5 from public recipes.\n\nPlan: Take PPO hyperparameters and training code from public sources such as Stable-Baselines3 RL Zoo and CleanRL continuous-action PPO. Record the source URL and commit for each setting. Run those settings on InvertedPendulum-v5 and Hopper-v5, then train InvertedPendulum-v5, Hopper-v5, Walker2d-v5, and HalfCheetah-v5 with the same recipe and three seeds."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_139",
    "options": {
      "A": "Goal: Collect the remaining public PPO wave2 cells by waiting for the current remote jobs to finish in launch order.\n\nPlan: Leave the InvertedPendulum and Hopper seeds running on compute node A, and leave the Walker2d, HalfCheetah, and Ant seeds running on compute node B. After the Ant-tuned cells reach 10 million steps, start the Humanoid cells from the same Ant-Humanoid launch script. When a group writes wave_status.json, copy summaries, checkpoints, and replay files back to the workspace. After all six environments are collected, use this wave as the public PPO baseline for later comparison with the proposed method.",
      "B": "Goal: Collect the remaining public PPO wave2 cells after measuring throughput and running Humanoid in parallel under the public recipe.\n\nPlan: Record steps per second, CPU and GPU use, checkpoint cost, and remaining time for each active PPO cell. Start the pending Humanoid seeds on compute node B or compute node C in parallel with the running Ant seeds, and do not duplicate cells that are already in progress. Train baseline cells with DummyVecEnv and n_envs=1. Run a short SubprocVecEnv or RL-Zoo native smoke on InvertedPendulum, Hopper, and Ant, and record it as a throughput diagnostic if it changes PPO batch or rollout size relative to the public recipe. Sync each finished environment when its wave_status file exists."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_140",
    "options": {
      "A": "Goal: Test a four-stage Hopper hopping controller against standing-still tags and absolute-speed thresholds.\n\nPlan: Add an explicit Hopper controller with crouch, push, flight, and land stages. Tune it on the train seeds, then evaluate once on test seeds that were not used for tuning. Declare success if the standing-still tags drop, or if mean absolute horizontal speed is at least 0.5 and vertical speed variation is at least 0.3.",
      "B": "Goal: Test a four-stage Hopper hopping controller against the PPO Hopper on the same task.\n\nPlan: Add an explicit Hopper controller with crouch, push, flight, and land stages. Tune it on the train seeds, then evaluate once on test seeds that were not used for tuning. Compare signed forward speed, episode length, and fall rate with the PPO Hopper baseline of mean return 3630, full 1000-step episodes with no fall, and forward speed of about 1 to 2 meters per second."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_141",
    "options": {
      "A": "Goal: Begin S1 by scoring a Swimmer traveling-wave controller against a Swimmer PPO mean from the public Zoo recipe.\n\nPlan: Train Swimmer PPO with the public Stable-Baselines3 Zoo recipe that uses observation normalization, and record the mean and run hash as the PPO baseline. Implement a two-joint traveling sine-wave controller with frequency, phase lag, amplitude, bias, and damping. Search those parameters on the train seeds with a budget of 50,000 simulator steps. Report the test normalized return against that PPO mean.",
      "B": "Goal: Begin S1 by scoring a Swimmer traveling-wave controller against the S0 Swimmer PPO mean of 111.\n\nPlan: Write a Swimmer task card and a protocol that sets the PPO mean to 111. Implement a two-joint traveling sine-wave controller with frequency, phase lag, amplitude, bias, and damping. Search those parameters on the train seeds with a budget of 50,000 simulator steps. Report the test normalized return against 111."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_142",
    "options": {
      "A": "Goal: Build a humanoid motion-imitation benchmark so the explicit controller can be scored against a published tracking baseline on held-out motions.\n\nPlan: Download a PHC checkpoint and a motion set from AMASS or BONES-SEED. Write a split of 100 train motions, 50 tune motions, and 100 held-out motions by family. Load the checkpoint and score tracking metrics on about 20 validation motions, and stop if the gap from the reported PHC numbers is larger than 10 percent. Treat the MuJoCo head-to-head table as complete and mark HalfCheetah as not available. After these benchmark files exist, start a Humanoid-v5 head-to-head controller.",
      "B": "Goal: Raise an explicit Swimmer controller toward the PPO return with typed patches and a replay gate, then apply the same loop to other MuJoCo environments.\n\nPlan: Search the 13 parameters of the Swimmer traveling-wave controller with CMA-ES, and report return divided by the PPO value 358.23. Build a Swimmer failure ledger and a bucket replay gate. Start typed-patch rounds from a mid-search config with return near 200, and accept a patch only when the target bucket improves and protected buckets do not get worse. After at least one accepted patch and a higher normalized return, run the same loop on Ant. Do the humanoid motion-imitation benchmark after a MuJoCo environment is near or above PPO."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_143",
    "options": {
      "A": "Goal: Test whether a Hopper controller made of phase, joint-target, PD, and balance rules can keep Hopper from falling on new seeds.\n\nPlan: Write a Hopper controller that updates an internal phase from height and foot touchdown, sets joint angle targets from a small table of knots or if-else rules, turns tracking error into torque with PD gains, and adds a torso pitch balance term. Search these scalar parameters with CMA-ES on training seeds in the simulator. Measure fall rate, return, and forward speed on seeds 20 to 29 against the Hopper PPO baseline return of 3630.3. The runtime map from observation and phase to torque uses only those parameters.",
      "B": "Goal: Test whether smooth neighbor and ensemble models trained on Hopper PPO rollouts can keep Hopper from falling on new seeds.\n\nPlan: Collect about 200,000 observation-action pairs from the Hopper PPO teacher on training seeds. Fit a distance-weighted K-nearest-neighbor regressor, random forests, and a depth-7 decision tree on that data. Measure fall rate, return, and forward speed on seeds 20 to 29. If all models still fall every episode, run five DAgger rounds on the two best models. In each round collect on-policy states, query the PPO teacher for actions, and refit. Treat any smooth model with holdout fall rate below 0.5 as a success. Store the teacher examples for runtime lookup. Do not call a neural network when the controller acts."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_144",
    "options": {
      "A": "Goal: Reuse Walker2d environments across candidates and compare search methods on the contact-phase controller.\n\nPlan: Keep the running three-family HZD and Bezier CMA-ES search with eight restarts and about 6000 evaluations per restart. Then implement a worker that keeps one Walker2d environment and resets it for each episode, and check that those rollouts match the path that creates a new environment every time. After that check, search the existing contact-phase velocity controller with CEM, random shooting, coordinate search, and CMA-ES started from known good parameters, using the same seeds and episode budget. Keep the Walker2d held-out target of 6175.5.",
      "B": "Goal: Change CMA-ES population and restart settings for Walker2d explicit-controller scouts.\n\nPlan: Keep the running three-family HZD and Bezier CMA-ES search with eight restarts and about 6000 evaluations per restart. Create a new Walker2d environment for every candidate episode, then roll out 32 seeds of 1000 steps. For later scouts, raise the CMA-ES population size so more workers can run at once, start new restarts from parameters already found, or use fewer restarts. After this scout, use the same CMA-ES pattern on the next explicit controller family, with the Walker2d held-out target of 6175.5."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_145",
    "options": {
      "A": "Goal: Test whether a new hand-written Walker2d gait program can walk and raise return above the n90 baseline.\n\nPlan: Write a new explicit controller that replaces the n90 spline targets with multi-regime gait laws and an outer speed schedule. Predeclare a few programs, including harmonic joint targets, a capture and push-off law, and a walk or jog mode bank. Run each program on a few Walker2d tune seeds and compare them with n90 on the same seeds. If no program is both stable and faster, use the rest of the tune budget for one rewritten program. Set parameters from physical intuition and from this small set of episodes, with no CMA-ES job. If a program meets the fall and speed gates, evaluate it on heldout seeds and a mini robustness set.",
      "B": "Goal: Test whether a residual overlay on the n90 Walker2d controller can raise speed after a small CMA-ES start and one manual edit.\n\nPlan: Keep the n90 phase-spline controller and its parameters as the walking base. Add an explicit residual overlay with at most twelve new speed, capture, or posture parameters. Run CMA-ES only on those overlay parameters, with population at most twelve, at most eight generations, and at most 96 tune episodes. After this init run, inspect the safest traces and apply one manual physical edit. A candidate may go to heldout seeds and a mini robustness set only when that manual edit is the selected controller."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_146",
    "options": {
      "A": "Goal: After the recent negative Walker2d speed families and the Hopper semantic-capacity scout, set the next work to a new return target or a new action interface.\n\nPlan: Record the Walker2d families of local parameter edits, gait-program replacement, residual overlay, scalar cap, and pre-bound allocation, together with the Hopper semantic-capacity scout, as the finished explicit-controller set. The next scheduled work is a review of the success number given returns near 60 percent of PPO, or a move of the next tests into impedance control or joint-position control.",
      "B": "Goal: After the recent negative Walker2d speed families and the Hopper semantic-capacity scout, set the next work to more structurally distinct explicit controllers until 60 approaches have real results.\n\nPlan: Write a registry of at least 60 structural signatures and mark the current Walker2d and Hopper families as already tried. Launch a first Hopper batch with new mechanisms, including CPG, VMC and SLIP, Raibert landing, contact FSM, and bang-bang limit cycles. Measure per-joint raw and post-bound action headroom on the current Hopper spline in the same round. Count one architecture family as one approach. The success target stays at plus 50 percent of PPO."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_147",
    "options": {
      "A": "Goal: Run a ResNet depth ladder and MLP and PirateNets pilots as the next experiments, and close the five unfinished n=6 pairs.\n\nPlan: Finish the five unfinished n=6 ResNet pairs with the current staged configs and the default direct configs. Run a ResNet depth ladder on five PDEs at 12, 18, and 24 layers with three seeds, and compare staged and direct at each depth. Run MLP and PirateNets pilots on two PDEs at 6 and 24 layers. Set the n=6 paired target to at least 5 wins out of 17. Put a matching autotune of the direct side in an appendix.",
      "B": "Goal: Run per-PDE retune and a matching direct autotune on the n=6 17-PDE comparison, and run a ResNet depth ladder and MLP and PirateNets pilots.\n\nPlan: Finish the five unfinished n=6 ResNet pairs. For each PDE where staged currently loses, run at least ten trials over BC and IC weights, stage split, and fine-tune learning rate. Give the direct side at least ten autotune trials per PDE on learning rate, loss weights, warmup, and gradient clip. Re-run the best staged config and the best direct config on three seeds. Run a ResNet depth ladder at 12, 18, and 24 layers and MLP and PirateNets pilots. Set the n=6 paired target to at least 11 wins out of 17."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_148",
    "options": {
      "A": "Goal: Measure whether staged training or direct training attains the lower L2RE when each method searches its own training hyperparameters.\n\nPlan: Keep both methods on a ResNet with 6 layers, width 100, and the Adam optimizer. Run Optuna TPE first on Burgers1D, Poisson2D_Classic, and Heat2D_Multiscale, with 50 trials per method, and keep the top trials as priors for later PDEs. Then run 30 Optuna trials per method at 20000 training steps on all 17 PINNacle PDEs. Direct training searches learning rate, initialization, boundary-weight multiplier, warmup, minimum learning-rate ratio, and gradient clipping. Staged training searches those knobs and also stage split, stage-3 learning-rate ratio, and stage-1 learning-rate multiplier. After the 17-PDE round, retrain each winning configuration on seeds 0, 1, and 2, and score each PDE by the lower of the two best L2RE values.",
      "B": "Goal: Measure whether staged training or direct training attains the lower L2RE when each method searches its own training hyperparameters.\n\nPlan: Keep both methods on a ResNet with 6 layers, width 100, and the Adam optimizer. Open four Optuna TPE studies, each with its own database: Poisson2D_Classic with direct training, Poisson2D_Classic with staged training, Heat2D_VaryingCoef with direct training, and Heat2D_VaryingCoef with staged training. Direct training searches learning rate, initialization, boundary-weight multiplier, warmup, minimum learning-rate ratio, and gradient clipping. Staged training searches those knobs and also stage split, stage-3 learning-rate ratio, and stage-1 learning-rate multiplier. Each study runs 30 trials, and each trial trains for 5000 steps. After the four studies finish, score each of the two PDEs by the lower of the two best L2RE values."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_149",
    "options": {
      "A": "Goal: Choose the next experiment after the Layer-1 Optuna studies on Poisson2D_Classic and Heat2D_VC.\n\nPlan: Take the four 30-trial studies as the paired result for staged training versus direct training at 5000 iterations, with the same trial count on both methods. Use the Poisson gap and the Heat near tie to forecast the 17-PDE win count. Next, run the same Optuna recipe at 5000 iterations on five more PDEs: Heat2D_Multiscale, Burgers2D, NS2D_LidDriven, PoissonBoltzmann2D, and HeatND. After that, rebaseline the depth ladder under Optuna on a small PDE set and present the depth result as the new main claim, with the n=6 table as per-PDE evidence.",
      "B": "Goal: Choose the next experiment after the Layer-1 Optuna studies on Poisson2D_Classic and Heat2D_VC.\n\nPlan: Keep the next run on Poisson2D_Classic and Heat2D_VC, and leave the Layer-1 direct best in place. Run a new staged-only Optuna search centered on that direct best after a half-depth first-stage transfer, with every staged knob still free inside bounds around the center. Search weight-init scale as a continuous log-uniform axis and keep bias init at zero. Delay pruning until a trial can finish the first stage, and reuse the Layer-1 staged trials as starting observations. Fit the run into one hour of wall time. If a best value sits near a bound, widen that bound and continue from the existing trials."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_150",
    "options": {
      "A": "Goal: Test whether the L1B Optuna recipe can give staged training a lower L2RE than direct training on the five PDEs that currently favor direct training.\n\nPlan: Run a staged-only Optuna search on Heat2D_Multiscale, Heat2D_ComplexGeometry, Poisson2D_ManyArea, NS2D_LidDriven, and Burgers2D. Use 80 trials per PDE at 5000 iterations and the same ten hyperparameters as L1B. Warm-start each study from that PDE's earlier direct-best and staged trials. After each study, run one staged probe and one direct probe at 20000 iterations. Count how many of the five PDEs flip to a staged win, and use that count to decide whether a 17-PDE full-fidelity search is viable.",
      "B": "Goal: Locate the staged hyperparameter basins on Poisson2D_Classic and Heat2D_VaryingCoef with a wider search range.\n\nPlan: Use ResNet with 6 layers on Poisson2D_Classic and Heat2D_VaryingCoef. Widen the Poisson learning-rate upper bound from 7.5e-3 to 2e-2 and the Heat fine-tune learning-rate-ratio lower bound from 3e-2 to 5e-3. Load the 80 L1B trials into each new study and add about 30 new trials per PDE at 5000 iterations. After the round, check that the new bests sit inside the widened bounds and that L2RE is no worse than L1B. If a new best is on a bound or L2RE is higher than L1B, widen that bound and run another short round on the same two PDEs."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_151",
    "options": {
      "A": "Goal: Continue Step-3 hyperparameter search on Poisson2D_Classic and Heat2D_VaryingCoef after round 2 found a new high learning-rate basin at 5k steps.\n\nPlan: Warm-start the existing 140-trial Optuna study and add 40 trials per PDE. Raise the Poisson learning-rate upper bound from 2e-2 to 5e-2, and add unused stage splits, lower fine-tune learning rates, and higher bc_mult. Place six enqueue seeds on both known basins at high learning rate, three with s30_60_10 and three with s20_60_20. Place six more seeds on settings such as very low fine-tune learning rate, very long S3, kaiming with high learning rate, and large init scale. After the 5k search, run 20k probes that keep the 5k fractions, that keep the S1 fraction and set S3 to 2000 steps with extra steps in S2, and that set S3 to 4000 steps. Also replay the round-1 Poisson config at 20k.",
      "B": "Goal: Continue Step-3 hyperparameter search on Poisson2D_Classic and Heat2D_VaryingCoef after round 2 found a new high learning-rate basin at 5k steps.\n\nPlan: Warm-start the existing 140-trial Optuna study and add 30 trials per PDE. Raise the Poisson learning-rate upper bound from 2e-2 to 5e-2. Place all six Poisson enqueue seeds inside the new 5k basin with stage split s20_60_20, fine-tune learning rate 8e-3, warmup 0.01, and grad clip 5.0, and only move learning rate and init scale around that basin. Place the six Heat seeds on the large init-scale mode. After the 5k search, take the new 5k-best config and run one 20k probe that keeps the same stage-split fractions. Keep that 20k number if it still beats the L1B baseline."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_152",
    "options": {
      "A": "Goal: Get a 20k-iteration staged error for vanilla MLP on Poisson2D_Classic and on Heat2D_VaryingCoef.\n\nPlan: Run a 40-trial staged Optuna search at 5k iterations on each PDE. Retrain the top three 5k configurations of each PDE for 20k iterations. Also retrain a few configs near the 5k winner by changing the stage split, the learning rate, or the last-stage learning rate. Report the lowest 20k error from this set as the staged MLP result.",
      "B": "Goal: Get a 20k-iteration staged error for vanilla MLP on Poisson2D_Classic and on Heat2D_VaryingCoef.\n\nPlan: Run a 40-trial staged Optuna search at 5k iterations on each PDE. Rank the trials by their 5k error and keep the winner of each PDE. Retrain that winner once for 20k iterations. Report that 20k error as the staged MLP result."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_153",
    "options": {
      "A": "Goal: Measure staged and direct L2RE at ResNet depths 12 and 24 on Poisson2D_Classic and Heat2D_VaryingCoef, and at depth 6 on three other PDE families.\n\nPlan: Train ResNet models at n=12 and n=24 with seed 0 on Poisson2D_Classic and Heat2D_VaryingCoef. Staged runs reuse each PDE's n=6 hyperparameters and set the stage split as a fraction of depth. Direct runs use a 6-trial Optuna search over learning rate and init scale at 5k iterations, then a 20k run of the best trial. Also train ResNet n=6 with seed 0 on Burgers1D, Wave2D_LongTime, and Heat2D_Multiscale. For each new PDE, run an 8-trial staged Optuna search at 5k iterations inside the learning-rate, init-scale, and stage-split ranges taken from the two existing PDEs, then 20k probes and a 6-trial direct search. If a staged best trial sits on a search bound, widen that bound by one decade and search again.",
      "B": "Goal: Measure whether stage-1 of staged training changes the curvature of a vanilla MLP PINN loss in the same way a ResNet skip connection does at initialization.\n\nPlan: On Poisson2D_Classic and Heat2D_VaryingCoef, evaluate three n=6 networks at seed 0: a vanilla MLP at direct-training initialization, a vanilla MLP after stage 1 of staged training, and a ResNet at direct-training initialization. Do not run further training. For each of the six settings, compute the top 50 Hessian eigenvalues of the full PINN loss with 50 Lanczos iterations, the NTK condition number of the PDE residual kernel on 256 collocation points, and the ratio of the largest Hessian eigenvalue to the tenth. Mark the geometry check as passed when the staged MLP sharpness and NTK condition number are at most twice the ResNet-init values and at most 0.3 times the vanilla-direct-init values. Write one spectrum table and one bar figure."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_154",
    "options": {
      "A": "Goal: Measure the locked Poisson ResNet staged run on extra seeds, then test staged training on PirateNets.\n\nPlan: Rerun the locked Poisson staged configuration that uses loss weights 1, 10000, and 10000 with seed 1 and seed 2. Rerun that same configuration with boundary weight 10 and with the collaborator stage split. Then train PirateNets with 6 layers on Poisson2D_Classic and Heat2D_VaryingCoef. For staged training, search a boundary-weight multiplier in 1000, 5000, and 10000 together with learning rate, initialization scale, and stage split. For direct training, search learning rate and initialization scale. Report relative L2 error on interior points at 20000 steps.",
      "B": "Goal: Measure staged training against direct training on Poisson2D_Classic and Heat2D_VaryingCoef with the PINNacle default loss weights.\n\nPlan: Set every loss weight to 1.0 for both methods and keep this value out of the search. Use ResNet with 6 layers and width 100, tanh activation, Glorot normal initialization, a constant learning rate, no gradient clipping, and 20000 training steps. Search learning rate and initialization scale for direct training. Search learning rate, the two stage learning-rate ratios, initialization scale, and stage split for staged training. Train both methods for 20000 steps and compare relative L2 error on interior points on these two PDEs."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_155",
    "options": {
      "A": "Goal: Collect a staged-versus-direct result for Poisson2D_Classic on the PINNacle setup-B ResNet with 6 layers.\n\nPlan: Use the existing Poisson2D_Classic direct result of relative L2 error 0.6791 as the baseline. Change staged training so stage 1 and stage 2 each use their own initialization scale. Search the staged method at 20000 steps over stage-1 learning rate, stage-2 learning-rate ratio, stage-3 learning-rate ratio, stage-1 initialization scale in [0.3, 6.0], stage-2 initialization scale in [0.3, 6.0], stage-1 step fraction in [0.1, 0.7], and stage-2 step fraction in [0.05, 0.7]. Start two seed trials from the current Poisson staged best and from the collaborator Poisson best setting. Run 40 trials at 20000 steps, then choose the next change from those 40 trials.",
      "B": "Goal: Collect a staged-versus-direct result for Heat2D_VaryingCoef on the PINNacle setup-B ResNet with 6 layers.\n\nPlan: Keep the Poisson2D_Classic numbers at direct relative L2 error 0.6791 and staged relative L2 error 0.6802. Run Heat2D_VaryingCoef next. Search Heat direct with 30 trials at 20000 steps over learning rate and initialization scale. Search Heat staged with 30 trials at 20000 steps over learning rate, initialization scale, stage-2 learning-rate ratio, stage-3 learning-rate ratio, stage-1 step fraction in [0.2, 0.5], and stage-2 step fraction in [0.1, 0.5]. Start one Heat staged trial and one Heat direct trial from the collaborator Heat best hyperparameters."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_156",
    "options": {
      "A": "Goal: Map the Poisson2D_Classic staged hyperparameter landscape under the PINNacle BC=1 setup.\n\nPlan: Let the running Poisson3D_CG and HeatND jobs finish and store the run files. Leave the Poisson direct baseline at L2RE 0.6791. On Poisson staged training with a ResNet of 6 layers and width 100, start from the current staged best values lr=0.000381, init_scale_s1=1.107, init_scale_s2=3.256, s2_lr_ratio=2.94, s3_lr_ratio=0.124, s1_frac=0.476, and s2_frac=0.056. For each of these seven knobs, run 10 trials at 20k iterations while holding the other six knobs at those values, for 70 trials in total. Record the L2RE versus knob curves, the range where L2RE rises by about 50 percent, and any trial that beats 0.5975. Use those bands as the search ranges for later Poisson width-200 and depth-12 cells, and scale the learning-rate band with width.",
      "B": "Goal: Set the paper table for staged versus direct training from the current PINNacle BC=1 cells and the two unfinished PDEs.\n\nPlan: Put the new PoissonBoltzmann2D numbers of staged L2RE 0.4736 versus direct L2RE 0.4954 into the main table. Let the Poisson3D_CG and HeatND jobs finish and add those two cells as well. After this seven-cell table is complete, write a report with four paper options. Option (a) keeps a PINNacle BC=1 main table whose ratios are 1.01 to 1.24. Option (b) moves the main table to PDEs where a direct PINN fails. Option (c) changes the data setup, including the BC weight, and looks for ratios of 5 to 10. Option (d) keeps option (a) as the main table and puts the older BC=5000 to 10000 results of 5 to 963 into an appendix. Follow option (d) and do not start a new hyperparameter sweep until this paper-structure choice is made."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_157",
    "options": {
      "A": "Goal: Search MLP Poisson again after the last MLP Heat staged run, and start ResNet on four missing PDEs, using earlier same-PDE runs to set the search box.\n\nPlan: On MLP Poisson, set each knob box from the smaller of the ResNet and PirateNets Poisson bests divided by 30 to the larger of those two bests multiplied by 30. Run 15 direct trials and 30 staged trials in that box, and put the ResNet Poisson best and the PirateNets Poisson best in as the first trials. On ResNet Helmholtz2D, PoissonND, Heat2D_Multiscale, and Wave2D_Heterogeneous, use the current wide search box, with learning rate from 3e-4 to 0.03 and the other knobs on their present ranges. Run 15 direct trials and 30 staged trials on each of those four ResNet PDEs.",
      "B": "Goal: Search MLP Poisson again after the last MLP Heat staged run, and start ResNet on four missing PDEs, using earlier best hyperparameters as the first trials.\n\nPlan: Keep the current wide search box on every cell, with learning rate from 3e-4 to 0.03 and the other knobs on their present ranges. Put the best hyperparameter set from a nearby backbone in as trial 0. Run 15 direct trials and 30 staged trials on each cell. On MLP Poisson, run one more search in that wide box with the ResNet Poisson best and the PirateNets Poisson best as the first trials. On ResNet Helmholtz2D, PoissonND, Heat2D_Multiscale, and Wave2D_Heterogeneous, use the same wide box and add a related prior as trial 0 when one exists."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_158",
    "options": {
      "A": "Goal: Take the next ResNet PINNacle step as one 6-hour slice of four cells, then read the results before planning more cells.\n\nPlan: Launch four cells that include staged widen on PoissonND, Burgers2D, and KuramotoSivashinsky, plus one remaining PDE such as Poisson1D or NS2D_BackStep. Run staged search on a PDE that already has a finished direct result. Set trial timeout to 180 or 240 minutes on the slow PDEs and keep the search ranges wide. After the four cells finish, read L2RE, whether the best hyperparameters sit on a search bound, and whether error stays near 1. Use that reading to choose the next four cells.",
      "B": "Goal: Finish the ResNet PINNacle 22-PDE grid by running the six remaining PDEs in one batch.\n\nPlan: Launch Poisson1D, Poisson2D_ManyArea, Heat2D_LongTime, Wave2D_LongTime, NS2D_BackStep, and NS2D_LongTime. For each PDE run a 15-trial direct search and a 30-trial staged search, so the batch has 12 cells. Set trial timeout to 120 minutes on Poisson1D, 180 minutes on Poisson2D_ManyArea and NS2D_BackStep, and 240 minutes on the three LongTime PDEs. Enqueue same-family Optuna priors and keep the current wide search ranges. Collect all 12 cells before the next audit, with a wall of about 5 to 6 hours and a cap of 8 hours. Treat KuramotoSivashinsky, PoissonND, and Burgers2D as finished PINN-fail or trivially-trainable cases. After this ResNet grid is complete, start PirateNets on the remaining PDEs."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_159",
    "options": {
      "A": "Goal: Decide the next step for cells where staged error is still above direct error after the three-backbone PINNacle grid.\n\nPlan: Build a table of the best staged error, the best direct error, and the best hyperparameters for every backbone and every PDE. Check whether Burgers2D, NS2D_BackStep, and PoissonND use one staged hyperparameter tuple on more than one backbone. Rerun staged training for those three PDEs on MLP, ResNet, and PirateNets with 20 random trials at the start of the search, 60 trials in total, and no trial taken from an earlier study. Keep the current direct baselines and the current three-stage recipe.",
      "B": "Goal: Decide the next step for cells where staged error is still above direct error after the three-backbone PINNacle grid.\n\nPlan: Build a table of the best staged error, the best direct error, and the best hyperparameters for every backbone and every PDE. Take PoissonND as a case where staged training stays worse than direct training on MLP, ResNet, and PirateNets. Take the MLP result on NS2D_BackStep as a result about direct training. Then either train the remaining cells with a new boundary-condition weight, with more stages, or with the Muon optimizer, or start writing the paper and put those cells in the discussion."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_160",
    "options": {
      "A": "Goal: Run the five-hyperparameter shared-stage setting on all three backbones of Burgers2D, PoissonND, and NS2D_BackStep.\n\nPlan: Run that setting on the nine cells given by these three PDEs and MLP, ResNet, and PirateNets. If the best point of a hyperparameter sits on a search bound, widen that bound and search again. Continue until all nine cells have been run and each of the five hyperparameters has its best point away from the search bounds.",
      "B": "Goal: Write the paper from the current 64 of 69 staged-versus-direct pass rate.\n\nPlan: Keep the 64 cells that already pass as the main table. Report ResNet on PoissonND, ResNet and PirateNets on Burgers2D, ResNet on KS, and PirateNets on GrayScott at their current best points in a limitation section. Begin paper writing from this table."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_161",
    "options": {
      "A": "Goal: Write the paper from the 69-cell 5-hp grid and the V78 cross-backbone transfer result.\n\nPlan: Use the 3-backbone 23-PDE 5-hp seed 0 table as the main result. Put the V33, V74, and V78 staged-versus-7-hp scores into a paper section on cross-backbone hyperparameter transfer. Draft sections 1 through 6 and the figures around that table, the 7-hp baseline design issue, and the P2DMA MLP case.",
      "B": "Goal: Check the 5-hp and 7-hp cell results, then run two-stage training with shared init and learning rate and add Burgers2D trials.\n\nPlan: Read every 5-hp and 7-hp study and list cells that still need runs. Train two-stage PINNs on five PDEs times three backbones, with the two stages sharing init scale and learning rate, and compare staged L2RE with direct training. Continue Burgers2D on MLP, ResNet, and PirateNets until each backbone has at least 20 complete trials."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_162",
    "options": {
      "A": "Goal: Write a paper from the 69-cell five-hyperparameter seed-0 grid and the PoissonND hyperparameter transfer.\n\nPlan: Use the staged-versus-direct relative L2 error table on 23 PDEs and 3 network types as the main result. Add a results section that applies one PoissonND five-hyperparameter setting from MLP to ResNet and to PirateNets. Discuss the seven-hyperparameter staged search and the Poisson2D_MA MLP case. Draft the method, results, and discussion around these tables. Then collect three random seeds on cells whose staged-to-direct ratio is near 1.1.",
      "B": "Goal: Test shared stage hyperparameters on representative cells and fill the missing Burgers2D trials.\n\nPlan: Recheck all five-hyperparameter and seven-hyperparameter cells for missing runs. Add Burgers2D trials on MLP, ResNet, and PirateNets until each network type has at least 20 finished trials. On five PDEs and all three network types, share initialization and learning rate across the two stages and compare staged relative L2 error with direct training. Use 30 trials and seed 0 on each of these 15 cells."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_163",
    "options": {
      "A": "Goal: Test whether progressive staged training on Poisson2D Classic gets better as K increases from 2 to 4.\n\nPlan: Train MLP, ResNet, and PirateNets on Poisson2D Classic, starting from the existing K2, K3, and K4 progressive checkpoints. At each growth step, compare the full network output, the PDE residual, and the L2RE before and after the new block is attached. Compare a copied output head with a newly initialized head, and check whether a 3-layer ResNet cut changes the residual pairing of the copied layers. Replay the final fine-tune with more steps at the same hyperparameters. Then rerun the K2, K3, and K4 comparison under the growth setting chosen by those checks.",
      "B": "Goal: Test whether progressive staged training on Poisson2D Classic gets better as K increases from 2 to 4.\n\nPlan: Train MLP, ResNet, and PirateNets on Poisson2D Classic with a fixed 3-layer growth block, so K2 ends at 6 layers, K3 ends at 9 layers, and K4 ends at 12 layers. Give each growth block 6666 steps, and keep a 6-layer schedule that uses the same total steps as K4. Search each schedule from a new sampler to 40 complete trials with the same hyperparameter bounds. Then rerun the best setting on train seeds 1 through 4. Report terminal L2RE and compare K2, K3, K4, and the same-compute 6-layer schedule."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_164",
    "options": {
      "A": "Goal: Read the three-backbone depth result from K-loss and step-loss figures on the existing Poisson-2D Classic trials.\n\nPlan: Use the current seed-0 Poisson-2D Classic K2, K3, and K4 trials for MLP, ResNet, and PirateNets. For each backbone, draw one K-loss figure of final relative L2 error at K2, K3, and K4, and one step-loss figure of relative L2 error and training loss versus optimizer step, with the growth-stage boundaries marked. Read whether error falls as K grows from these six figures.",
      "B": "Goal: Complete the fine-tune and growth diagnostics and then re-run the three-backbone Poisson-2D Classic depth gate.\n\nPlan: Take the current K4 < K3 < K2 count of 0 out of 3 on MLP, ResNet, and PirateNets as the depth result. Finish the fine-tune budget probes and the growth-preservation variants on the existing K3 and K4 checkpoints. After those diagnostics, choose a growth or fine-tune change and re-run seed-0 Poisson-2D Classic for the three backbones at K2, K3, K4, and the same-compute K2 extra schedule, with pass defined as K4 < K3 < K2 and K4 < K2 extra."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_165",
    "options": {
      "A": "Goal: Continue the Poisson2D_Classic repair work after the six loss figures.\n\nPlan: Treat the new K-loss and step-loss plots as a picture of the known jump when a new block is added on Poisson2D_Classic. Next, run a shared-absolute learning-rate fine-tune grid on the same Poisson2D_Classic K3 and K4 checkpoints, finish two replay runs from the same saved state for MLP, ResNet, and PirateNets, and search for a growth step that keeps the old network output on each backbone. If all three backbones pass that growth-step gate, rerun the Poisson2D_Classic K2, K3, and K4 main grid with the rule that K4 must beat K3 and K2. Put Wave2D_Heterogeneous and other hard PDEs in a later round after that seed-0 Poisson2D_Classic gate.",
      "B": "Goal: Test the growth step on a PDE where a one-block net still has large error.\n\nPlan: After each growth step, record the full network output, the PDE residual, and the training loss, and check that the loss falls below the previous stage after the jump. On Wave2D_Heterogeneous, and with Heat2D_VaryingCoef as a second check, run K1, K2, and K3 under the current growth rule and under a repaired growth rule from the same saved state. Call a case hard when K1 L2RE is at least 0.90, K2 is at most 0.90 times K1, and K2 is still at least 0.30. If a candidate misses that gate, switch to the next hard PDE and repeat the same K1 to K3 comparison. Start any K4 run only after the repaired K3 curve stays below K2."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_166",
    "options": {
      "A": "Goal: Select hard PDEs on which K=1 fails and K=2 improves but remains large.\n\nPlan: Mark K=1 as a failure when the network collapses to a trivial pattern, such as every method staying near a loss of 0.5, or when relative L2 error is at least 0.40 if that collapse is not scored directly. Also require the K=2 error to be at most 0.90 times the K=1 error and still at least 0.30. Run a separate K=1 search and a separate K=2 search for MLP, ResNet, and PirateNets. Keep a PDE only when all three networks meet every cutoff. If the K=1 error is below 0.40, reject that PDE and apply the same 0.40 rule to the next candidate.",
      "B": "Goal: Select hard PDEs on which K=1 fails and K=2 improves but remains large.\n\nPlan: Mark K=1 as a failure when its relative L2 error is at least 0.90, the band near an untrained predictor. Also require the K=2 error to be at most 0.90 times the K=1 error and still at least 0.30. Run a separate K=1 search and a separate K=2 search for MLP, ResNet, and PirateNets. Keep a PDE only when all three networks meet every cutoff. If the K=1 error is below 0.90, reject that PDE and apply the same 0.90 rule to the next candidate."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_167",
    "options": {
      "A": "Goal: Measure whether the reported SDT gain comes from optimizer restart or from shallow initialization, and pass a post-growth loss recovery test before LongTime staged training.\n\nPlan: Reuse the selected Vanilla and SDT runs on Heat2D-Multiscale, Poisson3D-Complex, and Navier-Stokes2D-Lid-Driven for MLP and PirateNets. Train two extra arms with those same hyperparameters. Vanilla plus Restart keeps the full deep network from step 0 and resets the optimizer and the stage learning rate at the SDT switch times. Shallow Warm-Start trains a shallow net, adds layers, and then trains every layer. Continue the LongTime vanilla jobs that are already running, and give the ablation the first open training slots. Keep LongTime staged training unlaunched until, on both LongTime PDEs and three backbones, the training loss after each added block falls below the value from before the add within 200 steps.",
      "B": "Goal: Measure whether the reported SDT gain comes from optimizer restart or from shallow initialization, and run LongTime staged training that copies a trained prefix and trains a new block.\n\nPlan: Reuse the selected Vanilla and SDT runs on Heat2D-Multiscale, Poisson3D-Complex, and Navier-Stokes2D-Lid-Driven for MLP and PirateNets. Train two extra arms with those same hyperparameters. Vanilla plus Restart keeps the full deep network from step 0 and resets the optimizer and the stage learning rate at the SDT switch times. Shallow Warm-Start trains a shallow net, adds layers, and then trains every layer. Continue the LongTime vanilla jobs that are already running, and give the ablation the first open training slots. In the same round, start staged training on Heat2D-LongTime and NS2D-LongTime. At each growth step copy the trained prefix, keep those layers fixed, train a newly initialized block, and finish with one full-network fine-tune."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_168",
    "options": {
      "A": "Goal: Test whether current_reset growth on Heat2D_LongTime and NS2D_LongTime recovers a lower objective after the network is deepened.\n\nPlan: Run six K2 growth tests, one for each pair of Heat2D_LongTime or NS2D_LongTime with MLP, ResNet, or PirateNets. At the growth step, copy the old prefix into a deeper network and randomly initialize the new layers and the output head. Record the training objective and real-GT L2RE before the first update and after 200 steps. Count a test as a pass only if the post-growth objective is at most twice the pre-growth objective, L2RE is at most 1.05 times the pre-growth L2RE, and the objective falls below 0.95 times the pre-growth value within 200 steps. If any of the six tests fails, keep the staged LongTime K1 to K5 studies unstarted and continue the vanilla K-grid. If all six pass, start the 30 staged LongTime studies with the same final depth and step budget as the vanilla runs.",
      "B": "Goal: Measure K-staged training on Heat2D_LongTime and NS2D_LongTime for PirateNets and MLP at K equal to 3, 4, and 5.\n\nPlan: Run 12 Optuna studies, one for each pair of Heat2D_LongTime or NS2D_LongTime, PirateNets or MLP, and K in {3,4,5}. Keep the existing K=1 and K=2 results as the K=1 and K=2 points. For a chosen K, train K growth stages and then one full-network fine-tune, so the run has K+1 training stages. In growth stage n, copy the prefix trained in the first n-1 stages, leave those prefix weights unchanged, and train only the new randomly initialized block and head. Use the same learning rate and step count for the first K stages, and use a separate learning rate for the last fine-tune stage. Set each Optuna search from the K=1 and K=2 hyperparameter basins already obtained on the same PDE and backbone."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_169",
    "options": {
      "A": "Goal: Get K-staged L2RE curves on Heat2D_LongTime and NS2D_LongTime for MLP and PirateNets.\n\nPlan: Start 12 Optuna searches for K=3, 4, and 5 on those two PDEs and two backbones. Each growth stage adds a 3-layer block, so the trained nets have 9, 12, and 15 layers. Keep the prefix frozen while the new block trains, then run one full-network fine-tune. Use the finished vanilla runs as the K=1 points and the historical n6 staged runs as the K=2 points, and set the growth and fine-tune learning-rate search from the selected K=2 hyperparameters of the same PDE and backbone.",
      "B": "Goal: Get K-staged L2RE curves on Heat2D_LongTime and NS2D_LongTime for MLP and PirateNets.\n\nPlan: Start Optuna searches for K=1 through K=6 on those two PDEs and two backbones. Each growth stage adds one layer, so K=1 trains a 1-layer net and K=6 trains a 6-layer net. Keep the prefix frozen while the new layer trains, then run one full-network fine-tune. Set the search from the known 6-layer optima with depth-muP: map the growth learning rate and init scale to the 1-layer versions, map the fine-tune learning rate to the matching K-layer version, and search around those centers."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_170",
    "options": {
      "A": "Goal: Compare staged depth training and vanilla training on Heat 2D varying coefficient and Poisson-Boltzmann 2D as the network grows by three-layer blocks.\n\nPlan: Use Heat 2D varying coefficient and Poisson-Boltzmann 2D with MLP and PirateNets. Grow the net by a three-layer block at each stage for K = 1, 2, 3, 4, and 5, so the final depths are 3, 6, 9, 12, and 15 layers. Reuse the existing K = 2 runs at depth 6, and run a hyperparameter search for K = 1, 3, 4, and 5 on each PDE and backbone, which is 16 searches. For each of those depths, train a vanilla net from scratch at the same final depth, and reuse the existing depth-6 vanilla runs. Set the hyperparameter ranges from the known K = 2 hyperparameter centers and from the earlier basin sizes.",
      "B": "Goal: Compare staged depth training and vanilla training on Heat 2D long time and Navier-Stokes 2D long time as the network grows one layer at a time.\n\nPlan: Use Heat 2D long time and Navier-Stokes 2D long time with MLP and PirateNets. Grow the net by one layer at each stage for K = 1, 2, 3, 4, 5, and 6, so the final depths are 1 through 6 layers. For each K, train a vanilla net from scratch at the same final depth. Set the hyperparameter ranges by depth-muP scaling from the known 6-layer hyperparameters. Plot L2RE against K for each PDE and backbone pair with a staged curve and a vanilla curve."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_171",
    "options": {
      "A": "Goal: Test whether adding more stages lowers error on Heat 2D with varying coefficient and Poisson-Boltzmann 2D.\n\nPlan: Use these two equations with MLP and PirateNets. Grow the network by a block of 3 layers at each stage. Set K to 1, 2, 3, 4, and 5, so the final depths are 3, 6, 9, 12, and 15. Reuse the K=2 runs, and run 16 hyperparameter searches for the remaining K values. Set each search range from the known K=2 optimum and basin on that equation and backbone. Train a vanilla network at each matching final depth.",
      "B": "Goal: Test whether adding more stages lowers error on Heat 2D long time and Navier-Stokes 2D long time.\n\nPlan: Use these two long-time equations with MLP and PirateNets. Grow the network by one layer at each stage. Set K to 1, 2, 3, 4, 5, and 6, so the final depth equals K. Use the staged runs and the same-depth vanilla runs collected at each K. Plot relative L2 error against K for staged training and vanilla training on each equation and each backbone."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_172",
    "options": {
      "A": "Goal: Measure staged-depth training and vanilla training from depth 3 to depth 15 on Heat2D-VaryingCoeff and Poisson-Boltzmann2D.\n\nPlan: On both PDEs, run MLP and PirateNets staged training at K=1, 3, 4, and 5 with a 3-layer growth block, and run vanilla training at n=3, 9, 12, and 15 as independent studies. Run the K=1 staged cell as a two-phase 3-layer search and run the n=3 vanilla cell as a from-scratch search. Reuse the existing setup-B results for K=2 and n=6. After collection, plot L2RE against K with a staged curve and a vanilla curve for each PDE and backbone.",
      "B": "Goal: Measure staged-depth training and vanilla training from depth 3 to depth 15 on Heat2D-VaryingCoeff and Poisson-Boltzmann2D.\n\nPlan: On both PDEs, run MLP and PirateNets staged training at K=3, 4, and 5 with a 3-layer growth block, and run vanilla training at n=9, 12, and 15. For depth 3, run one from-scratch 3-layer study and use that result as staged K=1 and as vanilla n=3. Reuse the existing setup-B results for K=2 and n=6. After collection, plot L2RE against K with a staged curve and a vanilla curve for each PDE and backbone."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_173",
    "options": {
      "A": "Goal: Add a second PB2D staged hyperparameter search so that L2RE falls as K grows and the reused K=2 point sits on the K=1 to K=3 line.\n\nPlan: Keep the finished PB2D staged studies for MLP and PirateNets. Convert the reused K=2 five-hyperparameter best run into a growth learning rate, a last-stage learning rate, and an init scale, and insert that triple as the first new trial. Search those three knobs on a log scale in a factor of 5.6 above and below each of those values. Add twelve new complete trials to each of the K=1, 3, 4, and 5 studies. Keep the current step counts, which stay near 6667 steps per stage for every K.",
      "B": "Goal: Add a second PB2D staged hyperparameter search so that L2RE falls as K grows and the reused K=2 point sits on the K=1 to K=3 line.\n\nPlan: Keep the finished PB2D staged trials for MLP and PirateNets. Take each backbone's K=2 study that used one shared learning rate, one shared init scale, and one last-stage ratio. Keep the trials with loss at most twice the best, drop those with last-stage ratio above 1, and fit a quadratic on the rest to set the three search ranges, with last-stage learning rate defined as learning rate times that ratio. Train 6000 steps in each stage, keep the growth ranges the same for every K, and scale the last-stage learning-rate range by 6 over 3K. Run ten search trials for K=3, 4, and 5, and add another batch if a best trial sits on a bound."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_174",
    "options": {
      "A": "Goal: Find hyperparameters for K-stage MLP training on Poisson-Boltzmann 2D at K=1, 3, 4, and 5.\n\nPlan: Continue the existing Optuna studies for those four K values. Keep the eight finished trials. Add twelve new trials to each study. Insert as trial 0 the effective hyperparameters from the finished K=2 five-knob run: growth learning rate 5.35e-3, fine-tune learning rate 1.38e-4, and init scale 2.693. Search each of those three quantities log-uniform from the center divided by 5.6 to the center times 5.6, which is growth learning rate 9.6e-4 to 3.0e-2, fine-tune learning rate 2.5e-5 to 7.7e-4, and init scale 0.48 to 15.1. For K=1, search only fine-tune learning rate and init scale. Keep seed 0, width 100, and AdamW.",
      "B": "Goal: Find hyperparameters for K-stage MLP training on Poisson-Boltzmann 2D at K=1, 3, 4, and 5.\n\nPlan: Open a new 10-trial Optuna search for those four K values. Use the finished three-knob Poisson-Boltzmann 2D MLP study that uses one learning rate and one init scale for the growth stages. From the trials whose loss is at most twice the best trial, remove the points with last-stage learning-rate ratio above 1 and a low growth learning rate, then set the boxes from the remaining points. Search growth learning rate from 0.00072 to 0.0159 and init scale from 0.0711 to 2.398, with no depth scaling. Search the last-stage fine-tune learning rate as learning rate times last-stage ratio from 2.45e-6 to 0.00322, and multiply that box by 6 divided by 3 times K. Give every stage 6000 steps, so each run has 6000 times (K+1) steps."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_175",
    "options": {
      "A": "Goal: Measure the deeper-K effect on three new PDEs and on two extra random seeds.\n\nPlan: Start deeper-K experiments on Poisson 3D with complex geometry, Navier-Stokes 2D lid-driven flow, and Heat 2D with complex geometry. Use the MLP backbone and the PirateNets backbone. Use depths K=2, K=3, and K=5. Train with staged depth training and with vanilla training. Use random seeds 0, 1, and 2. In each new study, run 10 complete Optuna trials. On Poisson-Boltzmann 2D, run the existing depth cells again at seed 1 and seed 2. Keep the best hyperparameters from seed 0 and do not run a new hyperparameter search.",
      "B": "Goal: Run Optuna trials on Poisson-Boltzmann 2D at K=3, K=4, and K=5 for staged depth training and for vanilla training.\n\nPlan: Use random seed 0. On Poisson-Boltzmann 2D, add 10 complete Optuna trials to staged depth training at K=3, K=4, and K=5. Add 10 complete Optuna trials to vanilla training at 9 layers, 12 layers, and 15 layers. Use the hyperparameter ranges from the last Poisson-Boltzmann 2D search. After this batch, fit a straight line to the log of K against the log of L2RE for staged depth training. If the R2 of that fit is below 0.95, add another batch of 10 trials on the same cells."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_176",
    "options": {
      "A": "Goal: Extend the deeper-K grid to three new PDEs and three random seeds.\n\nPlan: Run staged depth training and same-depth vanilla training with MLP and PirateNets on Poisson-3D complex geometry, Navier-Stokes 2D lid-driven flow, and Heat-2D complex geometry. Use depths K=2, 3, and 5, and run seeds 0, 1, and 2. Give each study 10 complete Optuna trials. On Poisson-Boltzmann 2D, rerun the current K-grid cells on seeds 1 and 2 with the seed-0 best hyperparameters held fixed.",
      "B": "Goal: Search hyperparameters at K=3, 4, and 5 for staged and vanilla training on Poisson-Boltzmann 2D and Heat-2D complex geometry.\n\nPlan: On Poisson-Boltzmann 2D at seed 0, add 10 more complete Optuna trials at K=3, 4, and 5 for staged depth training. Give vanilla training the same trial count at n=9, 12, and 15. After this batch, fit ln(K) versus ln(loss) for the staged runs, and if R-squared is below 0.95 add another 10-trial batch. Run the same depth grid on Heat-2D complex geometry at seed 0."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_177",
    "options": {
      "A": "Goal: Improve the Heat2D_ComplexGeometry log-log depth fit using the three depths n=6, n=9, and n=15.\n\nPlan: Keep Heat2D_ComplexGeometry at K=2, K=3, and K=5. For MLP and PirateNets, train both staged depth training and vanilla. Add ten more hyperparameter trials to each of the eight studies at K=3 and K=5, so each of those studies has twenty finished trials. Reuse the existing K=2 studies as the n=6 anchors. After this batch, fit the staged log-log line on n=6, n=9, and n=15.",
      "B": "Goal: Improve the Heat2D_ComplexGeometry log-log depth fit using the five depths n=3, n=6, n=9, n=12, and n=15.\n\nPlan: Keep the Heat2D_ComplexGeometry measurements at K=2, K=3, and K=5. Add K=1 at depth n=3 and K=4 at depth n=12 for MLP and PirateNets. For K=1, train one n=3 study per backbone; staged training at K=1 is the same run as vanilla. For K=4, train both staged depth training and vanilla. Search each new study with ten finished hyperparameter trials, then fit the staged log-log line on n=3, n=6, n=9, n=12, and n=15."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_178",
    "options": {
      "A": "Goal: Search PoissonBoltzmann2D at K=3, K=4, and K=5 together, and add H2DCG K=4 plus more K=3 and K=5 trials, to raise staged log-log R² to 0.98 or higher.\n\nPlan: On PoissonBoltzmann2D, add ten complete trials to each K=3, K=4, and K=5 cell for MLP and PirateNets under both staged and vanilla training. Continue CMA-ES on the K=4 staged studies and TPE on K=3 and K=5, and enqueue each backbone's best K=3 trial into the K=5 study and the best K=5 trial into the K=3 study. On H2DCG, add K=4 with ten complete trials per backbone and training mode, and add ten more complete trials to the staged K=3 and K=5 cells.",
      "B": "Goal: Finish the remaining H2DCG batch-2 vanilla K=5 cells, then jointly review PoissonBoltzmann2D and H2DCG and design the next PoissonBoltzmann2D search for staged log-log R² of 0.98 or higher.\n\nPlan: Continue the current H2DCG batch-2 studies until the remaining vanilla K=5 cells for MLP and PirateNets each have 20 complete trials. Keep PoissonBoltzmann2D at the collected K=4 rescue table, where staged log-log R² is about 0.85 for MLP and 0.93 for PirateNets. After both the PoissonBoltzmann2D rescue and this H2DCG batch have no remaining runs, send the two PDEs through one joint audit and one scientist round that designs the next PoissonBoltzmann2D hyperparameter search under the R² of 0.98 or higher criterion."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_179",
    "options": {
      "A": "Goal: Raise the PoissonBoltzmann2D SDT log-log R² after the latest collected K-grid batch.\n\nPlan: Start a new PoissonBoltzmann2D batch that adds ten complete trials to each of twelve cells at K=3, K=4, and K=5 for MLP and PirateNets, covering both SDT and vanilla. Run a CMA-ES study on MLP SDT at K=5 that enqueues the current K=3, K=4, and PirateNets K=5 best hyperparameters, then adds ten CMA-ES trials. Continue CMA-ES on the MLP and PirateNets K=4 SDT cells, and run TPE on the remaining cells.",
      "B": "Goal: Raise the PoissonBoltzmann2D SDT log-log R² after the latest collected K-grid batch.\n\nPlan: Add the new PoissonBoltzmann2D trials to MLP SDT at K=5, and add the same number of new vanilla trials at K=5. Run a CMA-ES study on that K=5 SDT cell starting from the current MLP K=5 best hyperparameters. After the new trials finish, refit the MLP log-log R² on the five points from K=1 through K=5, and compare the new K=5 SDT minimum with the new K=5 vanilla minimum."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_180",
    "options": {
      "A": "Goal: Continue the deeper-K study so that SDT log-log R² on Poisson-Boltzmann 2D and Heat2D CG can reach 0.98.\n\nPlan: Finish the remaining PirateNets cells on Poisson-Boltzmann 2D, then review that PDE. Design the next Poisson-Boltzmann 2D hyperparameter round from the new MLP and PirateNets results. Finish the running Heat2D CG depth cells in a second planning cycle and review Heat2D CG when that batch is collected.",
      "B": "Goal: Continue the deeper-K study so that SDT log-log R² on Poisson-Boltzmann 2D and Heat2D CG can reach 0.98.\n\nPlan: Finish the remaining PirateNets cells on Poisson-Boltzmann 2D and the running Heat2D CG depth cells under one planning cycle. When either remaining group stops, review both PDEs. Design the next experiment batch from that checkpoint, including the next Poisson-Boltzmann 2D hyperparameter round."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_181",
    "options": {
      "A": "Goal: Search PoissonBoltzmann2D MLP staged-depth training at K=5, and measure Heat2D_ComplexGeometry at K=1 with final depth 3.\n\nPlan: On PoissonBoltzmann2D with MLP, run a hyperparameter search for staged-depth training at K=5, and run vanilla training at depth 15 with the same number of completed evaluations as the K=5 staged-depth search. K=1, K=2, K=3, and K=4 in this MLP staged-depth series use the evaluations already collected. On Heat2D_ComplexGeometry, run K=1 with final depth 3 for MLP and for PirateNets.",
      "B": "Goal: Test whether PoissonBoltzmann2D MLP hyperparameters from K=4 transfer to K=5, and continue Heat2D_ComplexGeometry at K=2, K=3, K=4, and K=5.\n\nPlan: On PoissonBoltzmann2D with MLP at K=5, train seven networks that mix the K=5 parent values and the K=4 values of growth learning rate, init scale, and fine-tune learning rate. Then train seventeen vanilla networks of depth 15 so that staged-depth and vanilla at K=5 each have 57 completed evaluations. On Heat2D_ComplexGeometry, continue the running MLP and PirateNets studies at K=2, K=3, K=4, and K=5."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_182",
    "options": {
      "A": "Goal: Analyze the Heat2D_ComplexGeometry K-grid when TG-G has eight terminal cells, and continue TG-J and TG-K as a second PoissonBoltzmann2D experiment.\n\nPlan: Let Heat2D_ComplexGeometry TG-G finish its remaining cells. When all eight cells are terminal, compute for that PDE whether SDT and vanilla have the same number of completed hyperparameter evaluations at each K, whether the SDT K-loss R² for each backbone meets 0.98, and whether the K=1 n=3 point is present. Design the next Heat2D_ComplexGeometry runs from those checks, and run the missing K=1 n=3 search in that batch. Continue PoissonBoltzmann2D TG-J and TG-K to match evaluation counts and to search MLP K5.",
      "B": "Goal: Finish TG-J and TG-K on PoissonBoltzmann2D, then recompute the same-count SDT versus vanilla comparison and the K-loss R².\n\nPlan: Make TG-J and TG-K the next experiment step. TG-J adds hyperparameter evaluations on the four PoissonBoltzmann2D cells where SDT and vanilla now have different completed-evaluation counts, until both sides match. TG-K runs a CMA-ES search on MLP K5 around the current elite range and adds the same number of new vanilla evaluations. After both groups finish, recompute the eight-cell SDT versus vanilla table and the K-loss R² for each backbone. Keep Heat2D_ComplexGeometry TG-G running, and start analysis of that PDE after this PoissonBoltzmann2D recomputation."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_183",
    "options": {
      "A": "Goal: Bring Heat2D complex-geometry log-log R² to 0.98 on the staged-training depth grid.\n\nPlan: Run the next experiments on Heat2D with complex geometry for MLP and PirateNets. Add K=1 points at depth n=3 with 30 hyperparameter trials for each backbone, using search ranges taken from the K=2 runs. Expand the K=4 staged and vanilla searches to 30 trials from the current 10-trial studies, and bring the vanilla searches at K=2, K=3, and K=5 to 30 trials from their current studies.",
      "B": "Goal: Bring Poisson-Boltzmann 2D MLP log-log R² to 0.98 and continue the Heat2D complex-geometry depth grid.\n\nPlan: Run the next experiments on both Poisson-Boltzmann 2D and Heat2D with complex geometry. On Poisson-Boltzmann 2D MLP, add more hyperparameter trials at K=3 and K=4, or test gradient-clip thresholds between the 95th and 97th percentiles, until the K-loss log-log R² reaches 0.98. On Heat2D with complex geometry, expand the K=4 staged and vanilla searches to 30 trials, bring every vanilla search to 30 trials, and start 30-trial K=1 runs at depth n=3 for MLP and PirateNets."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_184",
    "options": {
      "A": "Goal: Find PoissonND ResNet SDT and PirateNets SDT hyperparameters that beat the existing vanilla L2RE.\n\nPlan: Start an Optuna TPE search for PoissonND ResNet SDT and an Optuna TPE search for PoissonND PirateNets SDT. Use 30 trials for each cell. Do not train vanilla. For ResNet, put the MLP transfer hyperparameters in as trial 0, keep s3_lr_ratio below 1, and search in the ranges estimated from earlier PoissonND trials. For PirateNets, put the growth learning-rate multiplier 0.149 in as trial 0 and 0.0149 in as trial 1, and search in the ranges that include 0.149. After the 30 trials, report the best L2RE of each cell against 0.000798 and 0.000467.",
      "B": "Goal: Find PoissonND ResNet SDT and PirateNets SDT hyperparameters that beat the existing vanilla L2RE.\n\nPlan: Start an Optuna TPE search for PoissonND ResNet SDT and an Optuna TPE search for PoissonND PirateNets SDT. Use 10 trials for each cell. Do not train vanilla. For ResNet, put the MLP transfer hyperparameters in as trial 0, keep s3_lr_ratio below 1, and search in the ranges estimated from earlier PoissonND trials. For PirateNets, put the growth learning-rate multiplier 0.149 in as trial 0 and 0.0149 in as trial 1, and search in the ranges that include 0.149. After the 10 trials, inspect whether the best point hits a bound or looks abnormal, and then design the next search."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_185",
    "options": {
      "A": "Goal: Continue hyperparameter search on Heat2D_ComplexGeometry for MLP and PirateNets so that SDT and vanilla each have 30 trials at every K.\n\nPlan: Keep the current Heat2D_ComplexGeometry Optuna studies and add trials until K=4 SDT and K=4 vanilla each have 30 evaluations for MLP and for PirateNets. Add vanilla trials at K=2, K=3, and K=5 until those vanilla studies also have 30 evaluations. Start a 30-trial K=1 study for each backbone with an n=3 network. Score every trial by real-GT L2RE and then refit the K-loss log-log line.",
      "B": "Goal: Run SDT hyperparameter searches on PoissonND with ResNet and on PoissonND with PirateNets against the existing vanilla L2RE on each backbone.\n\nPlan: Start one Optuna TPE study for PoissonND ResNet-SDT and one Optuna TPE study for PoissonND PirateNets-SDT. Set the search center from the best known hyperparameters on each backbone, and set the search range from the spread of earlier good trials. Enqueue those known points as the first trials, and keep the final-tune learning-rate ratio below 1. Score every trial by real-GT L2RE, and compare the new SDT best with vanilla L2RE 0.000798 on ResNet and 0.000467 on PirateNets."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_186",
    "options": {
      "A": "Goal: Bring Gray-Scott MLP, Gray-Scott PirateNets, and Burgers 1D ResNet staged training below the current vanilla error of each cell.\n\nPlan: Run a staged-training hyperparameter search on each of these three cells, with 10 trials in a batch and no vanilla runs. Keep depth at 6 layers and 20000 steps. Put the first trials at the hyperparameters from the backbone of the same PDE that already beats vanilla. If a batch of 10 trials stays above vanilla, read the new best points and the search bounds, then set the next batch of 10 trials from that basin.",
      "B": "Goal: Bring the Heat2D Complex Geometry staged K-loss curve to a log-log R2 of 0.98.\n\nPlan: Expand the Heat2D Complex Geometry K=4 staged and vanilla searches from 10 trials to 30 trials. Add trials until every vanilla K has 30 evaluations. Run the missing K=1 case as a 3-layer network with 12000 steps. If the staged log-log R2 stays below 0.98, add more trials at K=4 and K=5 or try gradient clipping."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_187",
    "options": {
      "A": "Goal: Decide the status of Burgers1D ResNet sequential fine-tuning after the first 10-trial rescue search.\n\nPlan: Take the 10 completed TPE trials as the rescue for Burgers1D ResNet sequential fine-tuning. Keep trial 3 as the best point, with L2RE 0.013279. Compare this value with the vanilla baseline of 0.012891. Record that sequential fine-tuning is 3.01 percent above the vanilla baseline, and leave this cell with no further hyperparameter trials.",
      "B": "Goal: Decide the status of Burgers1D ResNet sequential fine-tuning after the first 10-trial rescue search.\n\nPlan: Keep the 10 completed TPE trials and run a second 10-trial TPE batch on the same Burgers1D ResNet sequential fine-tuning cell. Place the search around the trial-3 basin. Set init_s from 0.02 to 0.8 so that init_s above 1 is out of the search. Set the learning rate from 5e-4 to 0.02, and set s12_frac, s12_lr_mult, and s3_lr_ratio around the same basin. Compare the new best L2RE with the vanilla baseline of 0.012891 after the second batch."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_188",
    "options": {
      "A": "Goal: Decide the next step for Burgers1D ResNet staged-depth training after three 10-trial rescue batches.\n\nPlan: After these 30 trials, stop the Burgers1D ResNet SDT rescue on seed 0. Keep trial 18 as the best result, with L2RE 0.012963, learning rate 3.32e-3, init_s 0.055, s12_lr_mult 0.837, and s3_lr_ratio 0.460. Record the gap to vanilla L2RE 0.012891 as 0.56 percent, with ratio 1.006. Do not start a fourth 10-trial hyperparameter search for this cell.",
      "B": "Goal: Decide the next step for Burgers1D ResNet staged-depth training after three 10-trial rescue batches.\n\nPlan: Start a fourth 10-trial TPE search for Burgers1D ResNet SDT on seed 0, with 20000 steps and vanilla target L2RE 0.012891. Open a new study with learning rate from 1e-6 to 1e-3, init_s from 0.1 to 3.0, s12_frac from 0.02 to 0.25, s12_lr_mult from 5.0 to 100.0, and s3_lr_ratio from 0.1 to 0.9. Set trial 0 to the historical ITER74 values learning rate 2.44e-5, init_s 0.796, s12_frac 0.164, s12_lr_mult 28.45, and s3_lr_ratio 0.798."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_189",
    "options": {
      "A": "Goal: Measure Burgers1D ResNet staged depth training L2RE against the seed-0 vanilla value 0.012891.\n\nPlan: Run a new 10-trial seed-0 search for Burgers1D ResNet staged depth training with 6 layers, width 100, and 20000 steps. Search learning rate, initialization scale, the share of steps on the first two stages, the first-two-stage learning-rate multiplier, and the fine-tune learning-rate ratio. Put the share of steps on the first two stages in the interval 0.10 to 0.25, and start trial 0 with that share equal to 0.15.",
      "B": "Goal: Measure PirateNets staged depth training L2RE on Wave2D_LongTime and Heat2D_LongTime when depth grows by 2 layers per stage to 8 layers.\n\nPlan: Run a 10-trial seed-0 search for PirateNets staged depth training on Wave2D_LongTime and a second 10-trial search on Heat2D_LongTime. Grow the network by 2 layers in each of four stages, then fine-tune all 8 layers. Use width 100 and 6000 steps in each of the five stages, and search learning rate, initialization scale, and the fine-tune learning-rate ratio."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_190",
    "options": {
      "A": "Goal: Fit the current support model on trampoline-only external targets while mattress files wait on official access.\n\nPlan: Treat SLP mattress files as unavailable until the academic application is approved, and treat PmatData as a source that needs a PhysioNet login. Use the twenty digitized Park and Eager trampoline points as the external target table. Run the R5 target-domain fit on this trampoline-only table.",
      "B": "Goal: Get mattress pressure targets from the SLP archive and from other public mattress data, then fit mattress and trampoline held-out targets in one table.\n\nPlan: Search local and remote paths for the SLP zip, write download and unzip receipts, and extract any archive that can be opened. Download PmatData from PhysioNet and write mattress pressure rows with a subject-level held-out split. Add these mattress rows to the digitized Park and Eager trampoline rows, then run the R5 target-domain fit on the combined table."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_191",
    "options": {
      "A": "Goal: Train a small neural network that maps person and pose information to mattress pressure maps, then evaluate that network on held-out SLP subjects.\n\nPlan: Use a trainable multilayer perceptron as the predictor head. Set decoded-map loss, learning rate, gradient clipping, and random restarts so that this network reaches decoded NRMSE of 0.05 or lower on 256 and 1024 training maps. Replay the earlier random-initialization encoded-MSE protocol on joints and metadata features. Then run the subject-held-out predictor and the content and geometry ablation with that network, and report NRMSE, contact-area error, and peak-to-mean ratio against the R20c, R22c, and R23d baselines.",
      "B": "Goal: Select a pressure-map predictor head that passes a training self-anchor test, then evaluate that head on held-out SLP subjects.\n\nPlan: Compare linear ridge and multilayer perceptron heads on decoded self-anchor using 256 and 1024 training maps. Adopt the head that reaches decoded NRMSE of 0.05 or lower, including a linear ridge head if it is the one that passes. Run a content and geometry feature ablation with that selected head, then run a subject-held-out predictor with three seeds on the same SLP split. Report held-out NRMSE, contact-area error, and peak-to-mean ratio, and compare them with the R20c, R22c, and R23d baselines."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_192",
    "options": {
      "A": "Goal: Set the next mattress evidence after public PmatData is confirmed to have no per-subject body shape.\n\nPlan: Treat the missing body-shape variables as a limit on further PmatData pressure-map gains. Request extra geometry files from the PmatData authors, or keep the current posture-conditioned PmatData NRMSE of 0.572 and describe the remaining error as a lack of body-shape inputs. Leave the SLP maps on the present metadata and marker baselines.",
      "B": "Goal: Test whether the PmatData physics-solver method improves pressure-map prediction on SLP.\n\nPlan: Use the public PmatData release in its current form. Port the plate and D0 load method that already reached about 0.572 NRMSE on PmatData onto SLP pressure maps under the existing SLP subject-held-out split. Score the transferred solver with NRMSE and compare it with the current SLP metadata and body-marker results near 0.867."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_193",
    "options": {
      "A": "Goal: Change the SLP pressure-map evaluation from held-out-person prediction to a same-person or same-mattress protocol.\n\nPlan: Keep scoring each predicted pressure map with pixel-to-pixel NRMSE on the recorded grid, with no search over where the person lies. Rank the plate solver, KNN, kernel ridge, and other baselines on that raw score on the current SLP subject-heldout split. Then run the next tests as same-subject few-shot adaptation, or as mattress-parameter calibration on one mattress. Keep the existing PmatData test that shifts, scales, and rotates maps as the pose-mismatch check.",
      "B": "Goal: Change the SLP pressure-map evaluation from fixed-pixel NRMSE to a minimum over unknown lying pose.\n\nPlan: Define the pressure-map error as the minimum NRMSE over translations and small rotations of the predicted map relative to the recorded map. Apply this score to the plate solver and to KNN, neural nets, ridge, and kernel ridge on the same SLP split. Choose the translation and rotation search range on training and validation maps only. Measure the same scores on SLP and PmatData at several map resolutions."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_194",
    "options": {
      "A": "Goal: Test whether learned pose, body-shape, and body-mass inputs, when passed through the mattress physics solver, reproduce held-out SLP pressure maps on gauge-free NRMSE.\n\nPlan: On the SLP subject-held-out split, train models that output the inputs of the plate mattress solver, namely body pose, body shape, and body mass or an equivalent contact load. Run the solver with oracle values of those inputs and record the gauge-free NRMSE of the solver pressure maps. Train a predictor that maps BodyMAP markers to those inputs, and train an image encoder that maps raw depth, RGB, and infrared frames to those inputs. Pass each predicted input through the plate solver and score the solver pressure maps with the same gauge-free NRMSE. Compare the learned-input error with the oracle-input error on the official split, the strict-subject split, and the subject-and-posture split.",
      "B": "Goal: Test whether a fine-tuned image encoder predicts SLP pressure maps with lower gauge-free NRMSE than the 72-marker kernel ridge fit.\n\nPlan: On the SLP subject-held-out split, fine-tune ResNet-18, ResNet-50, and ViT-S so that each network maps a raw depth, RGB, or infrared frame to a pressure map. Train each backbone with encoded mean squared error, a log-space loss, and a softmax KL loss, and repeat each setting with three seeds. Score every model with gauge-free NRMSE on the same held-out rows as the BodyMAP 72-marker kernel ridge fit, whose gauge-free NRMSE is 0.817351. Count a model as a success if it is at least 0.010 lower than that kernel fit, the paired interval excludes zero, and image shuffle and label shuffle controls raise the error. Then score each success on the official split, the strict-subject split, and the subject-and-posture split."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_195",
    "options": {
      "A": "Goal: Get mass, load, and geometry for the solver by requesting those fields from the SLP, PmatData, and BodyMAP authors.\n\nPlan: Rank three author requests as the next data step. Ask the SLP authors first for per-subject mass or applied load to add to the existing pressure, depth, and marker files. Ask the PmatData authors next for body geometry and mass. Ask the BodyMAP authors last for geometry, mass, and dataset splits. Run the next solver tests on the first source that returns pressure maps with geometry and with mass or load.",
      "B": "Goal: Get a grid of mattress surface force values for the solver from data that is already collected.\n\nPlan: Use the SLP height and weight labels as the scalar mass input. Set the missing field to a force value at each mattress sensor cell, measured by a load sensor that is not the pressure mat. For SLP, PmatData, and BodyMAP, label each missing field as already collected but unreleased, or never collected. Send access requests for fields labeled as already collected but unreleased. Search public mattress datasets for a published load sensor that is already paired with pressure maps."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_196",
    "options": {
      "A": "Goal: Test a train-only machine-learning map from PoPu Sensomatt readings to Tactilus pressure as the next validation route.\n\nPlan: Write a protocol that treats a train-only map from the 72-cell Sensomatt grid to the 1728-cell Tactilus map as the next mattress transfer model. On the five-subject paired split, train ridge, spatial ridge, kernel ridge, an MLP decoder, and a convolutional decoder. Compare them with the train-mean map, bilinear upsample, the forward plate solver, and a linear map. If the best learned model improves gauge-free NRMSE by at least 0.020 over the linear map, or reaches 0.480 or lower, take that learned map as the PoPu validation route. Check body-part labels only as optional extra inputs.",
      "B": "Goal: Test a mattress physics engine by mapping PoPu Sensomatt readings to Tactilus pressure and Tactilus pressure to Sensomatt readings.\n\nPlan: On the five-subject paired split, score linear regression, ridge, kernel ridge, an MLP, and a CNN from Sensomatt to Tactilus, and the same model families from Tactilus to Sensomatt. Record those scores as baselines that do not use a physics engine. Fit a physical model of how mattress foam carries force between the top face and the bottom face, with parameters chosen on training subjects only, and with sample-shuffle and label-shuffle controls. Count the physics engine as successful when both directions have lower gauge-free NRMSE than the best baseline on the held-out subject."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_197",
    "options": {
      "A": "Goal: Produce interaction videos so a viewer can judge whether the mattress and trampoline models look physically plausible.\n\nPlan: Render a first visual packet with the current support-model code and a 2D Pillow side view. Make at least four playable clips: a ball dropping onto a mattress, a ball dropping onto a trampoline, a block or capsule on a mattress, and one off-center or dual-contact scene. Each clip must last at least three seconds and show some surface motion. Search for Unitree G1 and SONIC or MaskedMimic assets. If a real asset is found, render a short lying or sitting rise attempt. If no asset is found, render a labeled kinematic proxy and write a missing-asset receipt. Deliver the clips for visual inspection.",
      "B": "Goal: Produce interaction videos so a viewer can judge whether the mattress and trampoline models look physically plausible.\n\nPlan: Search for a loadable Unitree G1 model. If none is found, build an articulated G1-like body. Render 3D perspective videos of four scenes: a ball on a mattress, a ball on a trampoline, a Unitree body on a mattress, and a Unitree body on a trampoline. Use a camera, lighting, and a deforming surface mesh so sag and contact are visible. For a 4 kg ball on the mattress, set the peak deflection to 30 to 80 mm, and show trampoline sag and rebound. Each clip must last at least four seconds. Deliver these four clips for visual inspection."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_198",
    "options": {
      "A": "Goal: Pause the mattress-data solver work and make videos of objects interacting with a mattress and a trampoline so a human can judge whether the physics looks real.\n\nPlan: Leave PoPu, SLP, and Pmat solver fitting paused. Make four 3D clips that pair a falling ball and a Unitree G1-like humanoid with a mattress and a trampoline. Drive the scenes in MuJoCo with a perspective camera, lighting, and a surface mesh that deforms under contact. For a 4 kg ball on the mattress, set the support so peak deflection is about 30 to 80 mm, and let the trampoline show sag and rebound. Look for a real G1 or BFM model first. If none is found, use a loadable G1-like articulated body for the two humanoid clips. Do not train a policy.",
      "B": "Goal: Pause the mattress-data solver work and make videos of objects interacting with a mattress and a trampoline so a human can judge whether the physics looks real.\n\nPlan: Leave PoPu, SLP, and Pmat solver fitting paused. Make at least four 2D or 2.5D clips with the current support models and a drawing renderer: a ball on a mattress, a ball on a trampoline, a block or capsule on a mattress, and one off-center or dual-contact mattress scene. Run each clip for a few seconds at about 24 frames per second with some surface motion. After that packet, look for a Unitree G1, SONIC, or MaskedMimic model and render a humanoid clip if the model loads. If the model is missing, write a missing-asset note and a labeled proxy. Do not train a policy."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_199",
    "options": {
      "A": "Goal: Continue the official G1 checkpoint get-up evaluation on rigid ground, mattress, and trampoline after both published checkpoints failed the 0.05 rad joint-limit gate.\n\nPlan: Change the joint-limit gate from 0.05 rad to 0.10 rad. Rescore the existing SONIC and ProtoMotions rigid rollouts under this gate and keep a table at 0.05, 0.10, 0.15, and 0.20 rad. Rebuild the SONIC low-latency binary and test it on the rigid scene. For ProtoMotions, run each start pose that passes the 0.10 rad rigid gate on the mattress and on the trampoline with the same checkpoint and the same initial state, then compare get-up success on matched poses with a paired exact test.",
      "B": "Goal: Continue the official G1 checkpoint get-up evaluation on rigid ground, mattress, and trampoline after both published checkpoints failed the 0.05 rad joint-limit gate.\n\nPlan: Compare the project's G1 MJCF joint ranges, limit margins, contact parameters, and timestep with the IsaacGym training setup used by SONIC and ProtoMotions. Record which joints and which limit convention differ. Change those simulator settings until joint positions stay inside the MJCF ranges on rigid ground. Then run the same official checkpoint from lying and sitting starts on the mattress and on the trampoline, and inspect the videos for sinking, bounce, floating, penetration, and active get-up motion."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_200",
    "options": {
      "A": "Goal: Obtain a rigid get-up baseline for the official frozen Unitree G1 checkpoints by changing the joint-limit gate, then compare those checkpoints on mattress and trampoline supports.\n\nPlan: Set the joint-limit violation gate to 0.10 rad and write that number into the evaluation protocol. Re-score the existing official SONIC and ProtoMotions rigid rollouts at 0.05, 0.10, 0.15, and 0.20 rad. Keep the start poses that pass at 0.10 rad. On those poses, run the official ProtoMotions checkpoint with the same reference and initial state on rigid, mattress, and trampoline supports. Compare per-pose get-up success between the rigid support and each soft support with a paired success test.",
      "B": "Goal: Obtain a rigid get-up baseline for the official frozen Unitree G1 checkpoints by editing the simulated joint ranges to the training numbers, then compare those checkpoints on mattress and trampoline supports.\n\nPlan: Compare each joint range in the project MuJoCo G1 model with the joint-limit numbers used to train ProtoMotions and SONIC. Record differences in range, limit convention, contact parameters, and time step, including the violation that is already present when a reference pose is loaded. Change the model or contact settings that differ from the training setup. Re-run the official ProtoMotions checkpoint on the rigid scene and record the joint-limit violation. Then run the same frozen checkpoint on the mattress and trampoline and render get-up videos for visual inspection of sinking, rebound, floating, and penetration."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_201",
    "options": {
      "A": "Goal: Choose how to use the R80 formal paired results after the joint-limit amplification hypothesis is not supported.\n\nPlan: Treat the R80 matrix as an evaluation of published BFM models on mattress and trampoline, and take one of three paths. The first path is to accept the eight pairs that passed the hard-floor joint-limit check, together with the mattress and trampoline-by-side observations, and start writing the paper. The second path is to collect more poses that pass the hard-floor joint-limit check and rerun the paired success-rate and joint-limit test, and the third path is to change the research question to the trampoline-by-side case where all three side poses failed.",
      "B": "Goal: Check the mattress simulation by running a published BFM from lying or sitting to standing on the mattress and reviewing the rendered video of that motion.\n\nPlan: Take a published BFM model and run the Unitree G1 from a lying or sitting pose to standing on the mattress, then render a 3D video of the full motion. Look at mattress indentation under the robot, rebound after load, and contact without floating or penetration. If a joint goes past its mechanical range during a motion that this BFM completes in its original training setup, compare the simulator joint ranges, contact parameters, and time step with that training setup, repair the mismatch, and render the video again."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_202",
    "options": {
      "A": "Goal: Make the mattress look softer under the robot by lowering the stiffness of the one-joint support.\n\nPlan: Use published foam indentation numbers for a very soft mattress to choose a lower stiffness for the present single-body vertical joint. Sweep stiffness until the robot sinks about 90 mm at rest, and set damping so a small rebound is visible. Re-render the same five get-up videos and check that the sink and rebound can be seen.",
      "B": "Goal: Make the mattress form a local dent under the robot while the edges stay nearly still.\n\nPlan: Replace the single-body mattress with a grid of bodies that each have their own vertical spring, and add coupling springs between neighboring cells. Run the same five get-up poses on this grid. Re-render the five videos and check that the contact cells sink while cells far from the load stay nearly still."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_203",
    "options": {
      "A": "Goal: Measure the trampoline deflection-versus-radius curve under a center iron ball and rebuild the trampoline as a circular Dirichlet membrane if that curve is not a cone.\n\nPlan: Place a 10 kg iron ball of radius 5 cm at the trampoline center and at the mattress center. After static equilibrium, record deflection versus radial distance r, fit a linear cone and an exponential cup to each profile, and require the trampoline rim displacement to be zero. If the trampoline profile is exponential, replace the 16 by 12 vertical-spring grid with a circular tension membrane that has Dirichlet edge conditions. Then render a ball-on-trampoline video and a G1-plus-BFM get-up video on that membrane.",
      "B": "Goal: Expand the cupping-failure evidence by adding a second BFM checkpoint and a mattress stiffness-coupling sweep.\n\nPlan: Repair the SONIC observation registry that previously reached only 17 of 135 tasks. If SONIC passes a rigid joint-limit gate, test it on the 380-segment cupping mattress. Download the full BFM-Zero weights, implement the backward map to a get-up latent vector z, and run the same rigid gate and cupping mattress test. Also sweep mattress total stiffness from 2000 to 6000 N/m and coupling ratio from 0.05 to 0.30 on a 3 by 3 grid with five development poses per cell. If a new checkpoint passes the rigid gate, compare it with ProtoMotions on the same five development poses."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_204",
    "options": {
      "A": "Goal: Make the next trampoline get-up video on a circular tensioned membrane.\n\nPlan: Build the trampoline as a circular sheet and hold the rim at zero displacement. Carry load through in-plane tension between neighboring nodes. Place a ball at the center and record how deflection changes with radius. Take the membrane as ready for video when that profile falls in a straight line to zero at the rim and forms a cone. Then render a ball-on-trampoline video and a ProtoMotions get-up video on the same five poses.",
      "B": "Goal: Make the next trampoline get-up video on a rectangular multi-segment spring grid.\n\nPlan: Call the existing multi-segment support XML with the surface set to trampoline. Use a rectangular 16 by 12 grid of independent vertical springs and set the neighbor coupling ratio to 0.75. Keep the existing trampoline stiffness and damping totals. Run the ProtoMotions checkpoint on the same five poses. Take the run as done when the grid shows a local dent, the far field stays below 80 mm, and a get-up video is written."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_205",
    "options": {
      "A": "Goal: Grow evidence that a local dent in the mattress stops get-up more than the trampoline sheet.\n\nPlan: Keep mattress get-up success of 0 out of 15 and trampoline get-up success of 3 out of 5 as the main contrast. Collect more mattress poses on the same dented mattress. Collect more trampoline poses for a larger paired sample of rigid floor and trampoline sheet. Build a new support whose sag pattern sits between a local dent and a full sheet.",
      "B": "Goal: Measure how get-up success changes with hardness on the mattress and on the trampoline.\n\nPlan: Keep the current mattress grid and the current trampoline sheet. Scale mattress spring stiffness and trampoline sheet tension across several hardness levels. At each level, average get-up success over the same poses. Plot hardness versus that mean success for the mattress and for the trampoline. On both plots, set hardness to how far a ball of fixed mass sinks when it sits still."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_206",
    "options": {
      "A": "Goal: Find the mattress spring count at which local depression fades and stand-up success returns.\n\nPlan: Keep the current per-spring stiffness rule and the six stiffness multipliers. Reduce the mattress grid from 380 springs to 40, then 4, then 1. At each grid, drop the 10 kg ball and run the same five ProtoMotions stand-up poses. Record the spring count where ball sink leaves the 212 to 222 mm band and stand-up success leaves 0 out of 5, and compare that transition with the trampoline at the same spring count.",
      "B": "Goal: Find the mattress stiffness assignment from a ball-sink estimate, then measure stand-up success versus hardness.\n\nPlan: Keep the 20 by 19 spring grid from a US Bonnell queen specification. Estimate how many springs sit under the 10 kg ball from spring density times ball area, then divide ball weight by that parallel stiffness. Change how stiffness is assigned to each spring and how the 220 mm travel stop is applied. Drop the 10 kg ball and run the same five ProtoMotions stand-up poses on that grid across the hardness levels."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_207",
    "options": {
      "A": "Goal: Collect a mattress hardness-sinking figure that shows simulated and analytical steel-ball depths together.\n\nPlan: Place a steel ball on the production 20 by 19 mattress at the listed hardness levels. For each level, record the simulated sinking depth and the analytical sinking depth from the spring-density estimate, and plot both curves on the same figure. Keep the coil count and bed size fixed. If the two curves disagree, update the production mattress scene and run the ball tests again. Continue the trampoline dt-convergence sweep after this mattress static check, with at most three time-step halvings per beta.",
      "B": "Goal: Collect trampoline dt-convergence results for all six beta values with a cap on time-step halvings.\n\nPlan: Keep the running trampoline characteristic-time job as the next experiment. At each beta, start from the coarse time step and allow at most three halvings of the time step. If the two time-step outcomes still disagree, record that beta as not time-step converged at the finest finished step and move to the next beta. Reuse the four completed caches at beta 0.25 and do not start a fifth finer level. Use the collected mattress oracle, mapping repair, and six-level hardness sweep as the current mattress results while this trampoline sweep finishes."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_208",
    "options": {
      "A": "Goal: Measure whether the compiled mattress matches the analytical sink under known loads.\n\nPlan: Take a mattress-only physics check as the next experiment. Keep the 20 by 19 grid and the area-normalized stiffness values from the unit contract. Apply known loads in a single-cell scene, a platen scene, and a steel-ball scene. Compare compiled sink and force with the analytical values, and inspect the steel-ball sink by visual check. Make the overall pass result fail when compiled sink disagrees with the analytical sink by more than the static error limit.",
      "B": "Goal: Measure how trampoline characteristic time and stable time step change with membrane tension.\n\nPlan: Take the circular membrane as the next experiment. For each remaining tension level, compute the discrete spectrum and the characteristic time, write the time-step plan from that spectrum, and then run the same five poses at those time steps. Allow at most four time-step levels per tension. If two adjacent levels do not agree, keep the finest completed level and mark that tension as not converged. Keep the Dirichlet boundary, the five poses, and the success gates unchanged."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_209",
    "options": {
      "A": "Goal: Bound runner memory with process RSS checks, and collect mattress and trampoline videos.\n\nPlan: Run the next experiment on a streaming runner that stores only online summaries and a short event window. Put each pose in a child process, and measure RSS as a function of physics step count. Record parent RSS, child RSS, and retained allocation, and compare task and physics labels with the per-step tracer. Use hundreds of gigabytes to a few terabytes of server memory, and stop a run if the memory growth rate would exhaust the host. Render 3D videos of a steel ball and an active G1 BFM on the mattress and on the circular trampoline.",
      "B": "Goal: Bound runner memory with a 16 GiB cgroup cap, and collect mattress and trampoline videos.\n\nPlan: Run the next experiment on a streaming runner that stores only online summaries and a short event window. Put each pose in a child process, and require a cgroup memory limit of 16 GiB. Record cgroup current memory, peak memory, and OOM events, and compare task and physics labels with the per-step tracer. If the node has no such cgroup, stop and ask an administrator to create a 16 GiB memory group. After that memory experiment passes, render 3D videos of a steel ball and an active G1 BFM on the mattress and on the circular trampoline."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_210",
    "options": {
      "A": "Goal: Test whether a streaming physics runner stays inside a 16 GiB cgroup memory limit, then collect mattress BFM videos.\n\nPlan: At the full physics rate, keep only running statistics for force, energy, contact, and warnings. Save trajectories at 50 Hz, and keep a short window around each event. Run each pose in a child process inside a cgroup with MemoryMax set to 16 GiB. Record cgroup memory.current, memory.peak, and memory.events as the memory evidence on a fixed horizon at three dt values and on 20 episodes. Start the formal server job only if that 16 GiB cgroup is present. After those receipts pass, collect the mattress BFM videos in the paired rerun.",
      "B": "Goal: Test whether a streaming physics runner keeps RSS from scaling with physics step count, then collect mattress and trampoline videos.\n\nPlan: At the full physics rate, keep only running statistics for force, energy, contact, and warnings. Save trajectories at 50 Hz, and keep a short window around each event. Run each measurement in a child process that exits when the measurement ends. On the server, record retained bytes, parent and child RSS, and RSS slope on a short dt grid and on 20 exiting episodes. Stop the job if the early slope would consume the remaining host memory. Then render 3D videos of a ball drop and an active G1 BFM get-up on the mattress and on the circular trampoline."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_211",
    "options": {
      "A": "Goal: Close the main claim that local mattress sinking lowers get-up success, using the current 18-pose pair result, and send this version for paper review.\n\nPlan: On the current mattress pair run at the nominal hardness, all 18 paired poses get up on the rigid control, all 18 fail on the soft mattress, the paired test gives p=3.8e-6, and 11 of 18 fail only when local sinking is allowed. Report the 15 physics-valid pairs as a second number. Run no new trials this round. Submit the current evidence package for review with a paper outline of the rigid-to-soft transfer gap, the 20 by 19 mattress, the circular membrane, the paired experiment, and the mechanism split.",
      "B": "Goal: Make the two ProtoMotions plots of get-up success versus hardness, one for the mattress and one for the trampoline.\n\nPlan: Use the current 18-pose mattress set and its six hardness levels. Plot mean get-up success against hardness on the mattress, averaging over those poses, and draw the rigid, soft, and mechanism arms on the same axes. Run the same official ProtoMotions get-up protocol on the circular trampoline over the same hardness grid and the same poses. Plot mean get-up success against hardness for the trampoline, and deliver these two figures as the next result."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_212",
    "options": {
      "A": "Goal: Measure get-up success against support hardness on the mattress and on the trampoline with the ProtoMotions policy.\n\nPlan: Make a mattress plot and a trampoline plot. Put hardness on the x-axis and mean get-up success over the pose set on the y-axis. For the mattress, use the six hardness multipliers from the 19-pose rigid and soft trials. For the trampoline, run the official ProtoMotions policy on the same pose set at six hardness levels and plot the same way. Keep the 20 by 19 mattress grid and the ProtoMotions policy unchanged.",
      "B": "Goal: Measure get-up success on four mattress arms that share one start, and repeat the same design with a second official policy.\n\nPlan: Run the 19-pose set from one shared settling start. Use four mattress arms: a rigid copy of the same grid, a grid whose cells share one vertical motion, a grid whose cells move independently, and the standard 20 by 19 mattress. Repeat those four arms with an official HumanUP G1 policy. Compare mean get-up success across the four arms for each policy. Keep physics-invalid trials out of the success count."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_213",
    "options": {
      "A": "Goal: Produce the mattress figure and the trampoline figure of standup success versus support hardness.\n\nPlan: For the mattress, plot pose-averaged standup success against hardness from the existing six-level ProtoMotions trials after excluding invalid trials. Draw the rigid-floor success as one point at infinite hardness, and add harder finite hardness multipliers so the plotted range includes both low success and near-rigid success. Pass each new hardness multiplier through the steel-ball theory and simulation check before the robot trials. For the trampoline, run pose-averaged standup trials across hardness levels with one fixed time step and plot success against hardness.",
      "B": "Goal: Qualify two policy families on independent recovery recordings and measure a matched rigid-to-soft standup effect.\n\nPlan: Scan the 403 BONES recordings for ProtoMotions until 30 recordings pass both the author's rigid-floor standup test and the project's rigid-floor standup test on five matched repeats. Find more licensed OpenTrack-compatible recovery recordings and run the same rigid qualification for OpenTrack. Then, on each qualified set, run a matched comparison of a rigid mattress, a mattress that bends as a whole, a mattress with local cupping, and a fully soft mattress, with five new repeats per recording. Set the hardness multiplier to 1 for all of these robot trials."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_214",
    "options": {
      "A": "Goal: Produce mattress and trampoline plots of get-up success against support hardness.\n\nPlan: Use the ProtoMotions get-up policy on both supports. Score success on a hardness grid that shows the drop from the rigid limit to a low success rate. Plot the soft-support curve and one rigid point at infinite hardness, to the right of the stiffest finite hardness and joined by a dashed line. Reuse the six existing mattress hardness levels, add stiffer mattress levels until that drop appears, and run the same grid on the trampoline. Check each new hardness with the steel-ball theory-versus-simulation test before the get-up trials.",
      "B": "Goal: Complete rigid qualification of independent get-up recordings and then compare two policy families on soft versus rigid supports.\n\nPlan: Continue testing the remaining BONES recovery recordings on the author recovery test and on the project's rigid get-up test until all 403 recordings are scored. Count a recording as qualified only if it passes both tests. Next, qualify an OpenTrack policy family from its own motion pool with the same rigid tests. Then, on each family that has at least 30 qualified recordings, run a matched rigid versus soft get-up comparison with five repeats per recording."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_215",
    "options": {
      "A": "Goal: Produce a mattress hardness versus get-up success figure.\n\nPlan: Apply the R98a validity filter to the R96b trials at alpha 0.25, 0.5, 1, 2, 4, and 8. Plot three series against alpha: full-soft mattress, common-mode mechanism, and rigid. Draw rigid as a baseline curve through those six alpha values. Draw the common-mode arm at each of the six alpha values.",
      "B": "Goal: Produce a mattress hardness versus get-up success figure.\n\nPlan: Plot the full-soft mattress success rate against alpha. Run rigid once and draw it as one point at alpha infinity to the right of the largest finite alpha, joined by a dashed line. Choose finite alpha values from near this rigid limit down to a softer regime where get-up success is low."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_216",
    "options": {
      "A": "Goal: Make a mattress hardness versus stand-up success figure that shows success falling from the rigid limit to a low rate.\n\nPlan: Keep the running rigid-qualification job on its own line. Draw stand-up success against hardness for the soft mattress, and place the rigid result once as a single point at infinite hardness joined to the last finite point by a dashed line. Then add harder finite mattress values, each first checked with a steel-ball sink test against theory, until that success rate approaches the rigid point.",
      "B": "Goal: Qualify at least 30 rigid stand-up clips from at least 15 source recordings on the BONES set.\n\nPlan: Continue the running 20-clip check of the placement and contact repair until most clips pass the original rigid gates in both test environments. Then re-run all 402 clips with the same gates and the same ProtoMotions controller. Count a clip only when it completes a clean stand-up on rigid ground. End this line when the 30-clip and 15-source counts are met."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_217",
    "options": {
      "A": "Goal: Produce a mattress hardness-versus-get-up-success figure from matched trials at finite alpha and at rigid infinity.\n\nPlan: Use one list of pose and repeat IDs at every finite alpha and at one rigid condition. Run those trials with the same initialization at each hardness. If a trial fails a physics or measurement check, run that same ID again until it gives a valid get-up result. Make the figure after every hardness has that same number of valid results. Choose finite alpha values so get-up success falls from the rigid limit to a low value as the mattress becomes softer. Plot only the full-soft finite-alpha curve and the single rigid infinity point.",
      "B": "Goal: Produce a mattress hardness-versus-get-up-success figure from the existing six finite-alpha paired trials and a later higher-alpha extension.\n\nPlan: Redraw the current full-soft trials at alpha 0.25, 0.5, 1, 2, 4, and 8 on the main panel. Place rigid as one point at alpha infinity to the right of alpha 8 and join it with a dashed line. Add a second panel that shows how many of the 19 poses pass the physics checks at each alpha. Compute each success rate on the poses that pass at that alpha. Then run higher alpha values on the same 19-pose set and again compute success on the poses that pass the physics checks at each new hardness."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_218",
    "options": {
      "A": "Goal: Obtain the mattress hardness-success curve on the final clip cohort with 50 Hz control and 6400 Hz physics.\n\nPlan: Use the current production mattress path with a 50 Hz policy and a physics step of 0.00015625 s, with 128 physics substeps in each 0.02 s control interval. Take the final independent clip cohort from the running 402-clip requalification. Run a matched full-soft and rigid hardness-success confirmation on that cohort with the same 20 by 19 topology, official policy, success metric, and physics step. Report the finite alpha curve and one rigid limit point from this runner.",
      "B": "Goal: Obtain a mattress production path with 50 Hz control, 200 Hz physics, and at least 10 times realtime on one GPU.\n\nPlan: Use a candidate mattress path with a 50 Hz policy and a physics step of 0.005 s, with one state update in each physics step. Replay the compiled 20 by 19 law, the steel-ball theory and simulation gates, and the existing dynamic task checks at this rate. Run many environments on one GPU and measure aggregate realtime as total simulated seconds divided by one-card wall time, including reset, policy, physics, and transfers. Report the physics-check outcome and the one-GPU realtime factor for this path."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_219",
    "options": {
      "A": "Goal: Complete the first stage by running the same physical probes on mattress and trampoline for all three simulation routes, then fitting those probes to real measurements.\n\nPlan: Build mattress and trampoline scenes for the Isaac PhysX FEM route, the task-specialized dynamics route, and the GPU deformable solver. Run one static and dynamic probe with the same geometry, loads, drop height, and output fields on each route for both supports. Fit the probe outputs to real mattress and trampoline measurements and score the cases that were not used in the fit. Make a cross-route table of the same observables and repair differences until the three routes match on those probes. Keep new policy families and RL paused until this probe path is done.",
      "B": "Goal: Complete the first stage by getting each of the three simulation routes to produce one hardness-success plot that a person accepts, with the three plots in agreement.\n\nPlan: For each route, finish the mattress and trampoline simulation and run one fixed existing get-up policy to make one hardness-success plot. Send each plot for human review. The first stage is complete when all three plots pass review and agree with one another. Use physical probes and real mattress and trampoline measurements to find and repair cases where a plot is unphysical or the three plots disagree. Do not start RL or a wide policy survey before the three plots exist."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_220",
    "options": {
      "A": "Goal: Produce Route A and Route C videos of a robot on the mattress and on the trampoline from solver states that pass the current validity gates.\n\nPlan: Start the Route A and Route C active G1 visual inspection runs only after each matching mattress or trampoline case has a valid physics measurement. Render no Route A or Route C robot video until those gates pass. Then render the same G1 pose on the mattress and on the trampoline. Treat those four videos as the human-acceptance visual record. Record contact and penetration from the valid physics runs that feed those videos.",
      "B": "Goal: Produce Route A and Route C videos of a robot on the mattress and on the trampoline from the solver states that exist now.\n\nPlan: Render the current Route A and Route C solver states with the same active G1 pose on the mattress and on the trampoline. Mark each of the four videos as physically invalid. Count those four videos as progress records. Start the human-acceptance visual inspection only after the matching mattress or trampoline case has a valid physics measurement. Save contact and penetration receipts from the same solver state that the video shows."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_221",
    "options": {
      "A": "Goal: Collect the Route-C mattress decomposition and trampoline static-isolation measurements under the listed input hashes.\n\nPlan: Move R132d to a host that has 120 GB of free disk and keep the 120 GB launch number. Copy the same code commit, the nine listed input hashes, and the same config to that host. Run the mattress decomposition cells and the trampoline static solves there, and store the residuals.",
      "B": "Goal: Collect the Route-C mattress decomposition and trampoline static-isolation measurements under the listed input hashes.\n\nPlan: Start R132d on compute node B with the Warp runtime and the nine listed input hashes that are on that host. Clear unused files so that free disk covers the run's declared output size of about 1 GB. Run the mattress decomposition cells and the trampoline static solves there, and store the residuals."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_222",
    "options": {
      "A": "Goal: Send Route C robot videos of the mattress and the trampoline now, and leave Route A videos until a damping check finishes.\n\nPlan: Record one Route C video on the mattress and one Route C video on the trampoline. Send each video when it passes its own visual gate. Leave Route A videos until a damping check on Route A finishes. Continue steel-ball matching across masses and heights as a separate line.",
      "B": "Goal: Match steel-ball drop behavior across Routes A, B, and C, and send Route A and Route C robot videos together when both are ready.\n\nPlan: Find parameters so that Routes A, B, and C match steel-ball drops at two or more masses and heights on the mattress and the trampoline. Run a Route A damping check and remaining visual checks during this matching work. Send Route A and Route C videos as one set after both routes are ready."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_223",
    "options": {
      "A": "Goal: Get first-seed results for two remaining tasks on PySR, full FEX, LLM-SR, and Direct.\n\nPlan: Run C3g from the cp3 family and I.29.16_0_0 from the LSR-Transform family. On these two tasks, run PySR at niterations 82 and 160, full FEX at the public scale of 1000 controller updates with 10 trees and top-10 refinement, and LLM-SR and Direct at 40 responses each. Keep the project API total at 100 dollars. Use the official splits from the remaining-nine protocol packages for these two tasks. After the two-task first-seed rows exist, use the wall time, unit cost, and recovery numbers from this round to plan the remaining seven tasks.",
      "B": "Goal: Get first-seed results for the remaining nine tasks on PySR, full FEX, LLM-SR, and Direct.\n\nPlan: Use the official splits from the remaining-nine protocol packages. Run PySR at niterations 82 and 160 on all nine tasks. Run full FEX at the public scale of 1000 controller updates with 10 trees and top-10 refinement on all nine tasks. If the project API cap is raised from 50 dollars to about 270 dollars, run LLM-SR and Direct at 40 responses on each of the nine tasks. If the cap stays at 50 dollars, run the PySR and FEX cells this round and do not run the LLM cells. After the nine-task first-seed rows exist, start repeated draws on the 13-task matrix."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_224",
    "options": {
      "A": "Goal: Run the four control methods on zb_rs and metal_nonmetal and record a score for each method.\n\nPlan: Run 5-seed trials of direct LLM sampling, official LLM-SR, PySR pair search, and FEX on zb_rs and metal_nonmetal. Connect the FEX control to the original FEX source code. Write a receipt for each method that includes the seed list, the LLM-call count, the candidate count, and the wall time.",
      "B": "Goal: Recover the metal_nonmetal SR-System score and compare SR-System with PySR and FEX on both tasks.\n\nPlan: Search the SR-System artifact directory and the old metal-nonmetal branch for a recorded metal_nonmetal run. If none is found, copy the metal_nonmetal problem package into an SR-System workspace and run LLM-MCTS to produce a LOOCV accuracy. Compare SR-System with PySR and FEX at equal candidate budgets on zb_rs and metal_nonmetal."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_225",
    "options": {
      "A": "Goal: Measure the four baselines on zb_rs and metal_nonmetal with five seeds for each method.\n\nPlan: Run direct LLM best-of-N, official LLM-SR, PySR pair search, and FEX tuple search as the four baselines. Make the next main experiment a five-seed score table of these methods on zb_rs and metal_nonmetal. Use ten LLM calls per seed for the LLM methods and a candidate ladder for the symbolic methods. Report the LLM methods by call count, and report PySR and FEX by search iterations, descriptor tuples, and wall time. Write the two-task table from the local receipts.",
      "B": "Goal: Recover a metal_nonmetal SR-System reference and compare SR-System with the four baselines on zb_rs.\n\nPlan: Search for a canonical SR-System metal_nonmetal run, and if none is found, copy the frozen metal_nonmetal package and run SR-System there. Make the next main experiment a comparison of SR-System with PySR and FEX on zb_rs. Run five-seed zb_rs trials of direct LLM best-of-N, official LLM-SR, PySR, and FEX tuple search. Use ten LLM calls per seed for the LLM methods and a candidate ladder for the symbolic methods. Compare the new zb_rs scores with the SR-System zb_rs score of 0.0918."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_226",
    "options": {
      "A": "Goal: Measure the direct and LLM-SR controls on the two material descriptor tasks with Claude Opus as the LLM provider.\n\nPlan: Run a one-seed direct best-of-N probe and a one-seed official LLM-SR probe with Claude Opus through Claude CLI. Use call budgets 2, 10, and 26 on zb_rs and metal_nonmetal. Write a cost receipt after the direct probe and apply a 50 USD project cap before the LLM-SR probe. Then build a control table that labels Haiku rows and Opus rows separately.",
      "B": "Goal: Measure the direct and LLM-SR controls on the two material descriptor tasks with an OpenAI or DeepSeek API as the LLM provider.\n\nPlan: Run five-seed direct best-of-N and five-seed official LLM-SR with an OpenAI or DeepSeek API. Use call budgets 26 and 90 on zb_rs and metal_nonmetal. Keep LLM-SR generated candidates separate from initial seeds and write per-seed manifests. Then build a control table from these API rows and the PySR, FEX, and SISSO rows."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_227",
    "options": {
      "A": "Goal: Measure direct best-of-N and official LLM-SR scores on zb_rs and metal_nonmetal with Claude Opus.\n\nPlan: Run direct best-of-N and official LLM-SR with Claude Opus on both tasks. Use call budgets of 2, 10, and 26. Score each 2D descriptor with the copied evaluators and add the Opus scores to the control table.",
      "B": "Goal: Measure direct best-of-N and official LLM-SR scores on zb_rs and metal_nonmetal with DeepSeek.\n\nPlan: Run direct best-of-N and official LLM-SR with DeepSeek on both tasks. Use call budgets of 26 and 90. Score each 2D descriptor with the copied evaluators and add the DeepSeek scores to the control table."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_228",
    "options": {
      "A": "Goal: Measure 5-seed DeepSeek scores for direct best-of-N and official LLM-SR on zb_rs and metal_nonmetal at 26 calls.\n\nPlan: Launch two LLM control runs on the frozen benchmarks. The first run is DeepSeek direct best-of-N with seeds 0 through 4 and a 26-call budget on both tasks. The second run is DeepSeek official LLM-SR with the same seeds, budget, and tasks. Call the language model through the DeepSeek API for every generation. Score every candidate with the copied evaluators, then add 5-seed means and sample standard deviations as the DeepSeek rows in the next control table.",
      "B": "Goal: Measure 5-seed Claude Opus scores for direct best-of-N and official LLM-SR on zb_rs and metal_nonmetal at 26 calls.\n\nPlan: Launch two LLM control runs on the frozen benchmarks. The first run is Claude Opus direct best-of-N with seeds 0 through 4 and a 26-call budget on both tasks. The second run is Claude Opus official LLM-SR with the same seeds, budget, and tasks. Call the language model through Claude CLI for every generation. Score every candidate with the copied evaluators, then add 5-seed means and sample standard deviations as the Claude Opus rows in the next control table."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_229",
    "options": {
      "A": "Goal: Measure whether PySR at 50,000 and 100,000 candidates beats SR-System on zb_rs LOOCV RMSE.\n\nPlan: Combine the 20-seed PySR runs at 50,000 and 100,000 candidates on zb_rs. Search scalar expressions on the full zb_rs labeled set and rank descriptor pairs by LOOCV RMSE. Compute mean RMSE, a 95 percent confidence interval, and the fraction of seeds with RMSE below the SR-System reference 0.0918. Write those numbers into the control table as the PySR comparison for zb_rs.",
      "B": "Goal: Measure the four baselines when candidate search and selection use training rows only.\n\nPlan: Inspect the PySR, real FEX, direct best-of-N, and official LLM-SR wrappers to see whether search, parameter fitting, or selection uses the full labeled set before LOOCV. Record that path for each method. Then rerun all four methods so that search and selection see training rows only, and score the chosen 2D descriptors once on held-out rows. Build the control table from those held-out scores."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_230",
    "options": {
      "A": "Goal: Find out whether PySR on zb_rs beats the SR-System LOOCV RMSE of 0.0918 more often when the seed count and the search budget increase.\n\nPlan: Run the PySR pair-frontier wrapper on the full zb_rs table, fit expressions on all rows, and rank descriptor pairs by LOOCV RMSE. Add seeds 5 through 19 at budget 50,000, run 20 seeds at budget 100,000, and report mean RMSE, the 95 percent confidence interval, and the fraction of seeds below 0.0918.",
      "B": "Goal: Find out what PySR, real FEX, direct LLM, and official LLM-SR score on zb_rs and metal_nonmetal when search uses training rows only.\n\nPlan: Read the four control wrappers and record whether search, parameter fitting, and candidate selection use the full label vector. Rerun PySR, real FEX, direct LLM, and official LLM-SR on zb_rs and metal_nonmetal so that search and selection use training rows only, and compute the final metric once on held-out rows for each selected 2D descriptor."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_231",
    "options": {
      "A": "Goal: Complete official LLM-SR zb_rs split coverage to 45 of 45 rows per budget, then send the control table to review.\n\nPlan: Take the scored DeepSeek LLM-SR zb_rs split rows from the earlier runs and generate the missing 13 rows at the 26-call budget and the 90-call budget. Collect 45 scored held-out rows for each budget. Rebuild the leakage-valid control table with mean, median, IQR, beat-rate, and the 1.5981 RMSE outlier. Send the table to review after this coverage completion.",
      "B": "Goal: Send the leakage-valid control table to review with official LLM-SR zb_rs reported at 32 of 45 scored rows per budget.\n\nPlan: Use the 32 scored DeepSeek LLM-SR zb_rs split rows at the 26-call budget and the 90-call budget. Report the beat-rate of 0 of 32 with median, IQR, and the 1.5981 RMSE outlier. Mark the LLM-SR zb_rs rows as partial coverage. Put the direct, PySR, FEX, and LLM-SR metal rows in the evidence table and send that table to review."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_232",
    "options": {
      "A": "Goal: Use the existing SR-System zb_rs result at a 10 to 20 candidate budget against PySR at 5000 iterations, and measure the held-out score of the already found formula.\n\nPlan: Keep the SR-System search at its 10 to 20 candidate budget. Set the PySR comparison at 5000 iterations. Re-score the descriptor formula that SR-System already found on zb_rs on the existing held-out splits, and record how far the score moves from 0.0918.",
      "B": "Goal: Score the existing SR-System zb_rs descriptor on the held-out splits and use those scores as the SR-System numbers in the baseline table.\n\nPlan: Take the descriptor formula that SR-System already found on zb_rs. Score that formula on the existing held-out splits that the baselines already use. Put these split scores into the baseline table as the SR-System numbers next to the baselines that already search on training compounds only."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_233",
    "options": {
      "A": "Goal: Get SR-System zb_rs held-out scores by running a new search on each of the 15 train splits.\n\nPlan: For every existing zb_rs split, run SR-System on the train rows only. Choose one descriptor from that search, then score it on the matching held-out rows. Use the 15 held-out scores as the SR-System numbers in the comparison with the current split-search baseline table.",
      "B": "Goal: Get SR-System zb_rs held-out scores by scoring the node 0010 descriptor on each of the 15 held-out splits.\n\nPlan: Read the descriptor formula from node 0010 of the existing zb_rs SR-System run. Score that formula on each of the 15 held-out splits. Record the 15 held-out scores and the change from 0.0918, and use those scores in the comparison with the current split-search baseline table."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_234",
    "options": {
      "A": "Goal: Make a six-method score table for zb_rs and metal_nonmetal from the current split results.\n\nPlan: Put SR-System, Direct best-of-N, official LLM-SR, PySR, real FEX, and SISSO into the table. For each method write Mean, Median, and Best and Worst from the current split scores, and add columns for protocol status and data source. On metal_nonmetal, set the Best value of Direct best-of-N, official LLM-SR, and PySR to 1.0. On zb_rs, write a refit SR-System row with Best 0.068 and Worst 0.122, and an original-coefficient SR-System row with Best 0.065 and Worst 0.122. Leave the zb_rs SISSO cell empty.",
      "B": "Goal: Make a six-method score table for zb_rs and metal_nonmetal from the current split results.\n\nPlan: Put SR-System, Direct best-of-N, official LLM-SR, PySR, real FEX, and the literature reference into the table. For each method write the mean split score as the table value. On zb_rs, write SR-System as the mean 0.0918 of the existing formula on the 15 splits, and write the literature reference formula as RMSE 0.1045. On metal_nonmetal, write the mean split accuracy of Direct best-of-N, official LLM-SR, PySR, and real FEX, and write the SISSO external formula as accuracy 0.9866. Use the columns method and mean score."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_235",
    "options": {
      "A": "Goal: Set the original-paper claim for the internal dimension d from the Qwen2.5 energy series.\n\nPlan: Finish the 512-prompt energy generations on Qwen2.5. Compute dimension d on the 103-prompt series and on the 512-prompt series, and choose a claim for d from those two tables. Record chi as the output-embedding fluctuation curve that peaks near T=0.3. Run the next analysis on output-end energy curves and dimension fits.",
      "B": "Goal: Test whether chi can peak at T_c, and measure criticality on internal transformer quantities.\n\nPlan: Take the not-sharp chi curve as a question of definition or of the measured layer or quantity. On the Qwen2.5-0.5B generations, recompute chi under other definitions and on other layers. Extract QK, attention, and OV at several layers, and compute the order parameter, the temperature derivative, and chi. Compare the interior peak temperature to the output energy T_c near 1.1."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_236",
    "options": {
      "A": "Goal: Measure whether the chi_attn peak temperature changes as the attention window grows on Qwen3-4B simple-wiki prompts.\n\nPlan: Extract connected chi on Qwen3-4B simple-wiki prompts at window sizes 128, 256, 512, and 1024. In this first extraction, compute each connected-chi confidence interval with 1000 bootstrap resamples for every head, temperature, and window. Then read T_peak at each window and judge whether the peak drifts with window size.",
      "B": "Goal: Measure whether the chi_attn peak temperature changes as the attention window grows on Qwen3-4B simple-wiki prompts.\n\nPlan: Extract connected chi on Qwen3-4B simple-wiki prompts at window sizes 128, 256, 512, and 1024. In this first extraction, compute each connected-chi confidence interval with 100 bootstrap resamples. Then use that first T_peak result to decide whether to raise the bootstrap count or to move to a different experiment."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_237",
    "options": {
      "A": "Goal: Get a finite-size scaling result for connected chi_attn on Qwen3-4B using S2 prompts.\n\nPlan: Extract connected chi_attn with 12 prompts and 16 seeds for window sizes 128, 256, 512, and 1024. Estimate T_peak at each window size with 100 bootstrap samples. If T_peak changes by more than 0.1 across window size and the change is monotonic, repeat the measurement with 48 prompts, 64 seeds, and 1000 bootstrap samples. If T_peak does not change by more than 0.1, switch to another experiment.",
      "B": "Goal: Get a finite-size scaling result for connected chi_attn on Qwen3-4B using S2 prompts.\n\nPlan: Extract connected chi_attn with 48 prompts and 64 seeds for window sizes 128, 256, 512, and 1024. Estimate T_peak at each window size with 1000 bootstrap samples. If T_peak changes by more than 0.1 across window size and the change is monotonic, treat the result as a phase transition. If T_peak does not change by more than 0.1, treat the result as a crossover."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_238",
    "options": {
      "A": "Goal: Decide which layer, observable definition, RoPE setting, and corpus give a sharp temperature-criticality signal.\n\nPlan: On Qwen3-4B, compute hidden-state energy and magnetization at the output embedding and at the first, quarter-depth, mid-depth, three-quarter-depth, and last decoder layers. At those same layers, compute connected chi, raw chi, thermal chi, and specific heat. Repeat the measurements with RoPE applied and with RoPE removed. Run the same grid on more than one corpus, including scifact and FineWeb. Rank the combinations by the location and height of the energy or susceptibility peak versus temperature.",
      "B": "Goal: Decide which confidence-interval rule can recover a replicable chi_attn signal from the stored 4B and 8B attention runs.\n\nPlan: Take the stored per-temperature chi_attn files from the Qwen3-4B and Qwen3-8B scifact runs. Add bootstrap resampling to the gate-calibration script. On those files, score a wider T_c window, a lower ratio threshold, a layer-pooled head score, and a point-estimate rule. Compare the token-shuffle null with the random-edge null on the same heads. Choose one rule from this search. Then score the 4B and 8B replication files under that rule."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_239",
    "options": {
      "A": "Goal: Determine whether including RoPE changes hidden-state layer energy on the grids where energy already shows a temperature trend.\n\nPlan: On Qwen3-4B, reuse the existing layer-energy prompts, layers, and temperature grid from the R55 and R62 corpora. For each corpus, run the model on the same prompt sequences twice and collect hidden-state energy: one forward with RoPE on, and one forward that disables RoPE inside attention. Compute signed T_c and the energy-versus-temperature curve for both modes. Write a table of per-layer differences in T_c and in the energy curve. Check that embedding-layer energy is the same in both modes.",
      "B": "Goal: Determine whether including RoPE changes the QK susceptibility result on the collected pre-RoPE and post-RoPE chi grids.\n\nPlan: Take the R94 and R95q pre-RoPE and post-RoPE QK chi tables for the existing model scales, layers, and corpora. For each mode, record whether the chi peak sits at the lowest measured temperature, and whether the peak height is less than twice the positive median. Summarize those boundary-peak and weak-peak counts as the RoPE include-or-exclude result. Continue to report layer energy from the current standard forward pass that already uses RoPE. Write a summary table of these chi counts for the current evidence set."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_240",
    "options": {
      "A": "Goal: Report how the defined energy, and chi, change across layers when RoPE is on and when RoPE is off.\n\nPlan: Read the Qwen3 4B and Qwen3 32B energy tables that list T_c at embedding, L0, L9, L18, L27, and L35 with RoPE and without RoPE. Read the matching Qwen3 4B chi tables. For each corpus, write energy T_c by layer in both settings and write whether chi still shows a peak. Use those lists to say which RoPE setting keeps T_c close across layers.",
      "B": "Goal: Set the next project direction after shuffled-token null reproduced layer T_c and after the V4 finite-size scaling, Binder, and overlap checks.\n\nPlan: Write a paper whose main claim is that the output-side temperature transition does not come from Transformer internal coupling. Use the shuffled-token null T_c match and the V4 finite-size scaling, Binder, and overlap numbers as the evidence for that claim. The other option is to define a new internal observable from the literature, write a success rule before any run, and measure that new quantity on the same models and corpora."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_241",
    "options": {
      "A": "Goal: Test whether text place names remain usable as spatial memory when room type, graph size, and goal type change.\n\nPlan: Run a real vision-language model on indoor images and measure how often two views of the same place receive the same name. Then change the room type, the graph size, and the goal type. Record when two places are joined by mistake, when one place is split by mistake, and when a goal is mapped to the wrong node. Report the rooms, graph sizes, and goal types where the names remain usable.",
      "B": "Goal: Test whether extra view and neighbor naming cues can support text-graph vision-language navigation.\n\nPlan: Run a real vision-language model on indoor images and measure how often two views of the same place receive the same name. Then add naming cues that combine multiple views, use neighbor rooms to tell similar places apart, and set how specific each name is. Measure how often the same place is matched and how often two places are joined by mistake after these cues are added. Test routing on the text adjacency graph built from these names."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_242",
    "options": {
      "A": "Goal: Measure how well an LLM can output name-list routes on Matterport3D graphs that use VLM place names.\n\nPlan: Use the Matterport3D connectivity graph as the map. Name each node with a Qwen2.5-VL-7B alias from the viewpoint image, and make a unique-name variant of those aliases. Give DeepSeek-R1 the named adjacency list and ask it for a route as a list of place names. Score each route by whether every consecutive pair is a real edge and by how much longer the path is than BFS. Repeat this test on at least five Matterport3D scans whose images cover at least 80 percent of viewpoints.",
      "B": "Goal: Measure how well A* can navigate Matterport3D scans on a named map built by a VLM from images.\n\nPlan: On one Matterport3D scan with at least 80 percent image coverage, use Qwen2.5-VL-7B to name each viewpoint from its image. Use the same VLM to decide which adjacent views are the same place, and build a named graph from those decisions and the connectivity edges. Run A* on this graph for random start-goal pairs, and score success rate and SPL against A* on the Matterport3D connectivity graph. Then run the same steps on at least five Matterport3D scans whose images cover at least 80 percent of viewpoints."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_243",
    "options": {
      "A": "Goal: Decide what to run next after the R2R vocabulary-overlap diagnostic returned a low ceiling.\n\nPlan: Take the current R2R and R4R runs as the evidence base for a thesis decision. Put three paths in front of the user. Path one keeps the named place graph and uses visual matching at each following step. Path two runs REVERIE and SOON on the same pipeline to test object-goal instructions. Path three writes a report from the R2R vocabulary mismatch numbers, the oracle routing result, and the existing R4R score. Launch the next experiment series after the user selects one of these paths.",
      "B": "Goal: Decide what to run next after the R2R vocabulary-overlap diagnostic returned a low ceiling.\n\nPlan: Run the current named-place navigation system on R2R, R4R, RxR, REVERIE, SOON, and CVDN. Use the official or public split of each dataset and the end-to-end protocol that a paper table would report. On R2R, score object-viewpoint following on the full val-unseen split. On R4R, score the all-instruction expansion of val-unseen. On REVERIE, SOON, CVDN, and RxR, add a task conversion and produce one scored run with official labels and the task success metric. After each listed dataset has a scored result, send the package for review."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_244",
    "options": {
      "A": "Goal: Test whether place naming on the eight-scan visual sample can pass the recall and per-scan false-merge gate.\n\nPlan: Use the existing 390 Qwen2.5-VL-7B place cards and the 320-pair visual sample from j33a, with each card storing a short name and anchors. Score every j35 linker rule and threshold on a gate that requires recall of at least 70 percent, aggregate false merge of at most 20 percent, and every scan false merge of at most 20 percent. On scans D7G3, Z6MF, and pLe4, assign a cause to each false merge and false negative. Re-check those pairs with GPT-4.1-mini, giving the model up to two extra neighboring MP3D images per endpoint. Run an eight-scan route evaluation only when a candidate meets the gate.",
      "B": "Goal: Test whether place naming on the eight-scan visual sample can pass the recall and per-scan false-merge gate.\n\nPlan: Use the same 390 real MP3D viewpoints and the same 320-pair visual sample from j33a. Call gpt-5.5 to write one card per viewpoint that contains a short name, stable anchors, and a detailed description of visible objects, layout, and distinctive cues. Run the linker on the 320 pairs with those cards, and report aggregate and per-scan recall and false merge. Score that linker on a gate that requires recall of at least 70 percent, aggregate false merge of at most 20 percent, and every scan false merge of at most 20 percent. Run an eight-scan route evaluation only when a candidate meets the gate."
    },
    "reference_answer": "B"
  },
  {
    "id": "case_245",
    "options": {
      "A": "Goal: Test whether GPT-5.5 detailed place cards pass the naming gate on the 8-scan set after every pair is labeled with the strict room-level same-place rule.\n\nPlan: Label the original 8-scan 320 visual pairs with the strict room-level same-place rule used on the 4 val-unseen scans. Use GPT-5.5 as the judge for this label pass. Recompute the existing GPT-5.5 linker outputs against these labels and report recall and false-merge with the four naming-gate conditions. Then write GPT-5.5 detailed cards and run the linker on more val-unseen Matterport scans under that same rule until the same-place count is at least 64.",
      "B": "Goal: Test whether a local 32B or 72B vision-language model can write place cards that pass the 8-scan naming gate.\n\nPlan: Serve a 32B or 72B open-source vision-language model on the server GPUs. Write detailed place cards for the 390 viewpoints in the current 8-scan Matterport set, using the same card prompt as the GPT-5.5 runs. Run the linker on the 320 visual pairs at threshold 0.25 and record recall and false-merge under the current same-place labels. If the four naming-gate conditions pass and recall is within 10 points of 72.33 percent, use this local model to write cards for later naming runs."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_246",
    "options": {
      "A": "Goal: Resume GPT-5.5 route-list stress on the eight real named graphs and independent GT repair on the 53 disputed pairs.\n\nPlan: When the OpenAI account accepts jobs, run GPT-5.5 on 14 of the 1392 prepared dense route queries on the eight real named graphs with the existing j39d script, then on 139 queries, then on all 1392 queries, and record the expected dollar cost before each of those three stages. In the same round, run GPT-5.5 on all 53 disputed visual pairs under the strict room-level contract, using the batch file that is already uploaded. Count this work against a 200 dollar API budget, with about 92 dollars already used.",
      "B": "Goal: Resume GPT-5.5 route-list stress on the eight real named graphs and independent GT repair on the 53 disputed pairs.\n\nPlan: When the OpenAI account accepts jobs, run GPT-5.5 on all 1392 prepared dense route queries on the eight real named graphs with the existing j39d script. In the same round, run GPT-5.5 on all 53 disputed visual pairs under the strict room-level contract, using the batch file that is already uploaded. Count this work against a 500 dollar API budget, with about 92 dollars already used."
    },
    "reference_answer": "A"
  },
  {
    "id": "case_247",
    "options": {
      "A": "Goal: Collect end-to-end named-route scores on the six official VLN benchmarks.\n\nPlan: Run the current string-route planner with route-exhaustion STOP on R2R, R4R, REVERIE, SOON, CVDN, and RxR. For each dataset, complete nested 1 percent, 10 percent, and full val-unseen splits. Use gpt-5.6-sol with reasoning-effort max for every model call. Continue each run until the selected split is complete, then start the next scale on the same pipeline. After the full split of all six datasets is collected, send the results to review.",
      "B": "Goal: Collect end-to-end named-route scores on the six official VLN benchmarks.\n\nPlan: Run the current string-route planner with route-exhaustion STOP on R2R, R4R, REVERIE, SOON, CVDN, and RxR. For each dataset, complete nested 1 percent, 3 percent, and 10 percent val-unseen splits, and reuse each finished split inside the next split. Use gpt-5.6-sol with reasoning-effort medium for every model call. Shuffle the selected episodes before each run, stop the run at 6 hours, and score the finished random prefix. After the 10 percent stage of all six datasets is collected, send the results to review."
    },
    "reference_answer": "B"
  }
]