Initial commit

A题/数值分析检验/Prompt/整合提示词.md

@@ -0,0 +1,595 @@
+TASK: Produce MODEL_SPEC v1.0 (canonical, frozen). Output JSON only.
+
+INPUT DATA (read from the uploaded markdown files):
+- State vector and inputs:
+  x(t) = [z(t), v_p(t), T_b(t), S(t), w(t)]
+  u(t) = [L(t), C(t), N(t), Ψ(t), T_a(t)]
+- Equations to include exactly:
+  (A) Power mapping P_tot(t) = P_bg + P_scr(L) + P_cpu(C) + P_net(N,Ψ,w)
+  (B) Terminal voltage V_term = V_oc(z) - v_p - I*R0(T_b,S)
+  (C) SOC ODE: dz/dt = - I / (3600 * Q_eff(T_b,S))
+  (D) Polarization ODE: dv_p/dt = I/C1 - v_p/(R1*C1)
+  (E) Thermal ODE: dT_b/dt = ( I^2*R0 + I*v_p - hA*(T_b - T_a) ) / C_th
+  (F) Tail ODE: dw/dt = (σ(N)-w)/τ(N) with τ_up, τ_down switching rule
+  (G) CPL closure:
+      R0*I^2 - (V_oc(z)-v_p)*I + P_tot = 0
+      I = (V_oc(z)-v_p - sqrt(Δ)) / (2*R0)
+      Δ = (V_oc(z)-v_p)^2 - 4*R0*P_tot
+  (H) V_oc(z) (modified Shepherd): V_oc(z)=E0 - K(1/z - 1) + A*exp(-B(1-z))
+  (I) R0(T_b,S) Arrhenius + SOH factor
+  (J) Q_eff(T_b,S) temperature + aging factor with max-floor
+
+METHODLOGY (must define explicitly in JSON):
+1) Domain constraints and guards:
+   - z ∈ [0,1], S ∈ (0,1], w ∈ [0,1]
+   - define z_eff = max(z, z_min) for V_oc to avoid 1/z singularity
+   - define Q_eff_floor to avoid negative capacity
+2) Event functions and termination logic:
+   Define three event functions:
+   gV(t)=V_term(t)-V_cut
+   gz(t)=z(t)   (threshold 0)
+   gΔ(t)=Δ(t)   (threshold 0)
+   Terminate at first crossing where any event function becomes ≤ 0.
+   Record termination_reason ∈ {"V_CUTOFF","SOC_ZERO","DELTA_ZERO"}.
+3) Define TTE precisely:
+   TTE = t* - t0 where t* is the earliest event time.
+   Use linear interpolation between the last two time samples for the event that triggers termination.
+
+DELIVERABLE (JSON ONLY):
+Return a JSON object with keys:
+- "states" (list of {name, unit, bounds})
+- "inputs" (list of {name, unit, bounds})
+- "parameters" (list of {name, unit, description})
+- "equations" (each equation as a string; use the exact variable names)
+- "guards" (z_min, Q_eff_floor, clamp rules)
+- "events" (definition of gV, gz, gΔ; termination logic)
+- "tte_definition" (interpolation formula and tie-breaking rule if multiple cross in same step)
+- "numerics" (method="RK4_nested_CPL", dt_symbol="dt", stage_recompute_current=true)
+
+VALIDATION (must be encoded as JSON fields too):
+- "dimension_check": list required units consistency checks
+- "monotonicity_check": SOC must be non-increasing while I>=0
+- "feasibility_check": Δ must be >=0 before sqrt; if Δ<0 at any evaluation, event triggers
+
+OUTPUT FORMAT:
+JSON only, no markdown, no prose.
+
+TASK: Produce MODEL_SPEC v1.0 (canonical, frozen). Output JSON only.
+
+INPUT DATA (read from the uploaded markdown files):
+- State vector and inputs:
+  x(t) = [z(t), v_p(t), T_b(t), S(t), w(t)]
+  u(t) = [L(t), C(t), N(t), Ψ(t), T_a(t)]
+- Equations to include exactly:
+  (A) Power mapping P_tot(t) = P_bg + P_scr(L) + P_cpu(C) + P_net(N,Ψ,w)
+  (B) Terminal voltage V_term = V_oc(z) - v_p - I*R0(T_b,S)
+  (C) SOC ODE: dz/dt = - I / (3600 * Q_eff(T_b,S))
+  (D) Polarization ODE: dv_p/dt = I/C1 - v_p/(R1*C1)
+  (E) Thermal ODE: dT_b/dt = ( I^2*R0 + I*v_p - hA*(T_b - T_a) ) / C_th
+  (F) Tail ODE: dw/dt = (σ(N)-w)/τ(N) with τ_up, τ_down switching rule
+  (G) CPL closure:
+      R0*I^2 - (V_oc(z)-v_p)*I + P_tot = 0
+      I = (V_oc(z)-v_p - sqrt(Δ)) / (2*R0)
+      Δ = (V_oc(z)-v_p)^2 - 4*R0*P_tot
+  (H) V_oc(z) (modified Shepherd): V_oc(z)=E0 - K(1/z - 1) + A*exp(-B(1-z))
+  (I) R0(T_b,S) Arrhenius + SOH factor
+  (J) Q_eff(T_b,S) temperature + aging factor with max-floor
+
+METHODLOGY (must define explicitly in JSON):
+1) Domain constraints and guards:
+   - z ∈ [0,1], S ∈ (0,1], w ∈ [0,1]
+   - define z_eff = max(z, z_min) for V_oc to avoid 1/z singularity
+   - define Q_eff_floor to avoid negative capacity
+2) Event functions and termination logic:
+   Define three event functions:
+   gV(t)=V_term(t)-V_cut
+   gz(t)=z(t)   (threshold 0)
+   gΔ(t)=Δ(t)   (threshold 0)
+   Terminate at first crossing where any event function becomes ≤ 0.
+   Record termination_reason ∈ {"V_CUTOFF","SOC_ZERO","DELTA_ZERO"}.
+3) Define TTE precisely:
+   TTE = t* - t0 where t* is the earliest event time.
+   Use linear interpolation between the last two time samples for the event that triggers termination.
+
+DELIVERABLE (JSON ONLY):
+Return a JSON object with keys:
+- "states" (list of {name, unit, bounds})
+- "inputs" (list of {name, unit, bounds})
+- "parameters" (list of {name, unit, description})
+- "equations" (each equation as a string; use the exact variable names)
+- "guards" (z_min, Q_eff_floor, clamp rules)
+- "events" (definition of gV, gz, gΔ; termination logic)
+- "tte_definition" (interpolation formula and tie-breaking rule if multiple cross in same step)
+- "numerics" (method="RK4_nested_CPL", dt_symbol="dt", stage_recompute_current=true)
+
+VALIDATION (must be encoded as JSON fields too):
+- "dimension_check": list required units consistency checks
+- "monotonicity_check": SOC must be non-increasing while I>=0
+- "feasibility_check": Δ must be >=0 before sqrt; if Δ<0 at any evaluation, event triggers
+
+OUTPUT FORMAT:
+JSON only, no markdown, no prose.
+
+TASK: Write a deterministic, language-agnostic specification for TTE computation.
+
+INPUT DATA:
+- MODEL_SPEC.events and MODEL_SPEC.tte_definition from Prompt 1
+- A simulated time grid t_k = t0 + k*dt, k=0..K
+- Arrays sampled at each grid point:
+  V_term[k], z[k], Δ[k]
+
+METHODOLOGY:
+1) Define event signals:
+   gV[k] = V_term[k] - V_cut
+   gz[k] = z[k] - 0
+   gΔ[k] = Δ[k] - 0
+2) Crossing rule:
+   A crossing occurs for event e when g_e[k-1] > 0 and g_e[k] ≤ 0.
+3) Interpolated crossing time for event e:
+   t_e* = t[k-1] + (0 - g_e[k-1])*(t[k]-t[k-1])/(g_e[k]-g_e[k-1])
+   (If denominator = 0, set t_e* = t[k].)
+4) Multi-event tie-breaking:
+   If multiple events cross in the same step, compute each t_e* and choose the smallest.
+   If equal within 1e-9, prioritize in this order:
+      DELTA_ZERO > V_CUTOFF > SOC_ZERO
+5) Output:
+   - TTE_seconds = t* - t0
+   - termination_reason
+   - termination_step_index k
+   - termination_values at t* using linear interpolation for (V_term, z, Δ)
+
+DELIVERABLES:
+A) “TTE_SPEC” section: the above as precise pseudocode with no ambiguity.
+B) A minimal test suite (exact numeric arrays) containing 3 tests:
+   Test 1: voltage cutoff triggers
+   Test 2: SOC hits zero first
+   Test 3: Δ hits zero first (power infeasible)
+For each test, provide expected outputs exactly (TTE_seconds, reason, t*).
+
+VALIDATION:
+- Must detect the correct earliest event (by construction of tests).
+- Must reproduce expected t* to within absolute error ≤ 1e-9 in the tests.
+- Must never take sqrt of negative Δ during event evaluation (use sampled Δ).
+
+OUTPUT FORMAT (strict):
+1) Header line: "TTE_SPEC_v1"
+2) Pseudocode block
+3) "TESTS_v1" as JSON with {tests:[...]} including expected outputs
+No additional text.
+
+TASK: Produce a deterministic function-level design for simulation with RK4 + nested CPL.
+
+INPUT DATA:
+- MODEL_SPEC from Prompt 1
+- TTE_SPEC from Prompt 2
+- Scenario definition: provides u(t) = [L(t),C(t),N(t),Ψ(t),T_a(t)] for any t
+- Initial state x0 = [z0, v_p0, T_b0, S0, w0]
+- Fixed constants: dt, t_max
+
+METHODOLOGY:
+Define these pure functions (no side effects):
+1) params_to_constitutive(x, params):
+   returns V_oc, R0, Q_eff at current state (with guards z_eff, floors)
+2) power_mapping(u, x, params):
+   returns P_tot
+3) current_cpl(V_oc, v_p, R0, P_tot):
+   returns Δ and I using the specified quadratic root
+4) rhs(t, x, u, params):
+   computes dx/dt using I(t) found by CPL closure
+
+RK4 step (must be spelled out exactly):
+Given (t_n, x_n):
+- Compute u_n = scenario.u(t_n)
+- Stage 1 uses rhs(t_n, x_n, u_n)
+- Stage 2 uses rhs(t_n+dt/2, x_n + dt*k1/2, u(t_n+dt/2))
+- Stage 3 uses rhs(t_n+dt/2, x_n + dt*k2/2, u(t_n+dt/2))
+- Stage 4 uses rhs(t_n+dt, x_n + dt*k3, u(t_n+dt))
+- x_{n+1} = x_n + dt*(k1 + 2k2 + 2k3 + k4)/6
+After updating, clamp states to bounds (z,S,w) as per MODEL_SPEC.
+
+Event evaluation:
+At each grid point, store V_term, z, Δ.
+After each step, check crossings using TTE_SPEC.
+
+DELIVERABLES:
+A) A complete “SIM_API_v1” specification listing:
+   - Function signatures
+   - Inputs/outputs (including units)
+   - Exactly what arrays are stored each step
+   - Termination output bundle
+B) A single canonical output schema:
+   "trajectory" table columns exactly:
+   t, z, v_p, T_b, S, w, V_oc, R0, Q_eff, P_tot, Δ, I, V_term
+   plus metadata: dt, t_max, termination_reason, t_star, TTE_seconds
+
+VALIDATION:
+- Must state the convergence requirement:
+   step-halving: compare dt vs dt/2 with:
+   max|z_dt - z_dt2| < 1e-4 and relative TTE error < 1% (exactly these thresholds)
+- Must include feasibility guard: if Δ becomes negative at any rhs evaluation, trigger event DELTA_ZERO.
+
+OUTPUT FORMAT:
+Return YAML only with keys: SIM_API_v1, OutputSchema, ValidationPlan.
+No prose.
+
+TASK: Output BASELINE_CONFIG_v1 as JSON only (parameters + scenario schedule).
+
+INPUT DATA:
+- MODEL_SPEC parameter list (Prompt 1)
+- Scenario concept: 6-hour alternating profile with smooth transitions using:
+  win(t;a,b,δ)=1/(1+exp(-(t-a)/δ)) - 1/(1+exp(-(t-b)/δ))
+  and L(t)=Σ L_j*win(t;a_j,b_j,δ), similarly for C(t), N(t)
+
+METHODOLOGY:
+1) Choose δ = 20 seconds exactly.
+2) Define a 6-hour schedule with exactly 6 segments in seconds:
+   Segment table fields:
+   name, a_sec, b_sec, L_level, C_level, N_level, Ψ_level, T_a_C
+3) Use the example normalized levels:
+   standby:    L=0.10 C=0.10 N=0.20
+   streaming:  L=0.70 C=0.40 N=0.60
+   gaming:     L=0.90 C=0.90 N=0.50
+   navigation: L=0.80 C=0.60 N=0.80
+   Include exactly one “poor signal” hour where Ψ_level is lower than the rest.
+4) Freeze initial conditions:
+   z0 in {1.00,0.75,0.50,0.25}; v_p0=0; w0=0; S0=1; T_b0=T_a(0)
+5) Freeze numerics:
+   dt=1.0 second; t_max=24*3600 seconds; seed=20260201
+
+DELIVERABLE:
+JSON object with keys:
+- params: {name:value} for every parameter in MODEL_SPEC
+- scenario: {delta_sec, segments:[...], win_definition_string}
+- initial_conditions: list of z0 values and fixed other inits
+- numerics: {dt, t_max, seed}
+
+VALIDATION:
+- segments must cover [0,21600] seconds without gaps (allow overlaps only via smooth win)
+- all input levels must lie within required bounds (L,C,N,w in [0,1], Ψ in (0,1])
+
+OUTPUT FORMAT:
+JSON only. No markdown.
+
+TASK: Execute BASELINE_CONFIG_v1 through SIM_API_v1 and return deliverables.
+
+INPUT DATA:
+- BASELINE_CONFIG_v1 (Prompt 4)
+- SIM_API_v1 (Prompt 3)
+- TTE_SPEC_v1 (Prompt 2)
+
+METHODOLOGY:
+For each z0 in {1.00,0.75,0.50,0.25}:
+1) Simulate trajectory until termination.
+2) Compute TTE via event interpolation.
+3) Compute summary metrics:
+   - avg(P_tot) over [0,t*]
+   - max(I), max(T_b), min(Δ) over [0,t*]
+   - energy_check = ∫ P_tot dt (Wh) and compare to nominal energy 14.8 Wh baseline
+
+DELIVERABLES (must be returned in this order):
+A) “TTE_TABLE_v1” as CSV text with rows for each z0:
+   z0, TTE_hours, termination_reason, t_star_sec, avg_P_W, max_I_A, max_Tb_C
+B) “FIGURE_SPEC_v1” as JSON listing exactly 4 plots to generate:
+   1) SOC z(t)
+   2) Current I(t) and power P_tot(t) (dual axis)
+   3) Battery temperature T_b(t)
+   4) Discriminant Δ(t)
+Each plot must specify:
+   title, x_label, y_label(s), filename (png), and which trajectory columns to use.
+C) “VALIDATION_REPORT_v1” as JSON with:
+   - monotonicity_pass (true/false)
+   - any_negative_delta_before_event (true/false)
+   - energy_check_values (per z0)
+
+VALIDATION CRITERIA (hard):
+- SOC must be non-increasing for all runs.
+- V_term must never be NaN/inf.
+- Energy check must be within [5 Wh, 20 Wh] for z0=1.00 (otherwise FAIL).
+If any check fails: output only FAIL + the validation JSON.
+
+OUTPUT FORMAT:
+A) CSV block
+B) JSON block
+C) JSON block
+No prose.
+
+TASK: Run convergence/robustness checks for baseline scenario.
+
+INPUT DATA:
+- Same configuration as Prompt 5, but run two numerics:
+  A) dt = 1.0 s
+  B) dt = 0.5 s
+- Use identical params and scenario.
+
+METHODOLOGY:
+For each z0:
+1) Simulate with dt and dt/2 until termination.
+2) Compare z(t) by resampling dt/2 solution at dt grid (take every 2nd sample).
+3) Compute:
+   z_diff_inf = max_k |z_dt[k] - z_dt2[2k]|
+   tte_rel_err = |TTE_dt - TTE_dt2| / TTE_dt2
+4) Event-location robustness:
+   For each run, report the last two bracketing samples for the triggering event and the interpolated t*.
+
+DELIVERABLES:
+A) “STEP_HALVING_TABLE_v1” CSV:
+   z0, z_diff_inf, tte_rel_err, pass_bool
+B) “EVENT_BRACKET_REPORT_v1” JSON:
+   for each z0: {reason, (t_k-1, g_k-1), (t_k, g_k), t_star}
+C) Single line verdict:
+   "ROBUSTNESS_PASS" or "ROBUSTNESS_FAIL"
+
+VALIDATION (hard thresholds):
+- z_diff_inf < 1e-4
+- tte_rel_err < 0.01
+All z0 must pass or verdict is FAIL.
+
+OUTPUT FORMAT:
+CSV, then JSON, then verdict line. No prose.
+
+TASK: Produce a scenario matrix and attribute TTE reductions to drivers.
+
+INPUT DATA:
+- BASELINE_CONFIG_v1
+- Choose z0 = 1.00 only
+- Define 8 scenarios total:
+  S0 baseline
+  S1 brightness reduced: L(t) scaled by 0.5
+  S2 CPU reduced: C(t) scaled by 0.5
+  S3 network reduced: N(t) scaled by 0.5
+  S4 signal worsened: Ψ(t) replaced by min(Ψ, Ψ_poor) for entire run
+  S5 cold ambient: T_a = 0°C constant
+  S6 hot ambient:  T_a = 40°C constant
+  S7 background cut: P_bg reduced by 50%
+
+METHODOLOGY:
+1) For each scenario, run simulation and compute TTE_hours.
+2) Compute ΔTTE_hours = TTE(Si) - TTE(S0).
+3) Rank scenarios by most negative ΔTTE (largest reduction).
+4) For top 3 reductions, compute “mechanistic signatures”:
+   avg(P_tot), max(I), min(Δ), avg(R0), avg(Q_eff)
+
+DELIVERABLES:
+A) SCENARIO_TTE_TABLE_v1 (CSV):
+   scenario_id, description, TTE_hours, ΔTTE_hours, termination_reason
+B) DRIVER_RANKING_v1 (JSON):
+   ordered list of scenario_id with ΔTTE_hours
+C) MECH_SIGNATURES_v1 (CSV) for top 3 reductions:
+   scenario_id, avg_P, max_I, min_Δ, avg_R0, avg_Qeff
+
+VALIDATION:
+- All scenarios must terminate with a valid event reason.
+- No scenario may produce NaN/inf in stored columns.
+
+OUTPUT FORMAT:
+CSV, JSON, CSV. No prose.
+
+TASK: Global sensitivity on TTE using Sobol (Saltelli sampling), deterministic.
+
+INPUT DATA:
+- z0 = 1.00
+- Baseline params from BASELINE_CONFIG_v1
+- Select exactly 6 uncertain scalar parameters (must exist in params):
+  k_L, k_C, k_N, κ (signal exponent), R_ref, α_Q
+- Define ±20% uniform ranges around baseline for each.
+- Sampling:
+  N_base = 512
+  Saltelli scheme with seed = 20260201
+
+METHODOLOGY:
+1) Generate Saltelli samples (A, B, A_Bi matrices).
+2) For each sample, run simulation to get TTE_hours.
+3) Compute Sobol first-order S_i and total-order ST_i.
+
+DELIVERABLES:
+A) SOBOL_TABLE_v1 (CSV):
+   param, S_i, ST_i
+B) SOBOL_RANKING_v1 (JSON): params ordered by ST_i descending
+C) COMPUTE_LOG_v1 (JSON): N_evals_total, failures_count (must be 0)
+
+VALIDATION:
+- failures_count must be 0.
+- All S_i and ST_i must lie in [-0.05, 1.05] else FAIL (numerical sanity).
+
+OUTPUT FORMAT:
+CSV, JSON, JSON. No prose.
+
+TASK: UQ for TTE by stochastic usage paths; output CI + survival curve.
+
+INPUT DATA:
+- z0 = 1.00
+- Baseline params
+- Base deterministic inputs L0(t), C0(t), N0(t) from scenario
+- Stochastic perturbations: OU processes added to each of L,C,N:
+  dX = -θ(X-0)dt + σ dW
+  Use θ=1/600 1/s (10-minute reversion), σ=0.02
+- Enforce bounds by clipping final L,C,N to [0,1]
+- Runs:
+  M = 300 Monte Carlo paths
+  seed = 20260201
+
+METHODOLOGY:
+1) For m=1..M, generate OU noise paths on the same dt grid.
+2) Build L_m(t)=clip(L0(t)+X_L(t)), etc.
+3) Simulate → TTE_m.
+4) Compute:
+   mean, std, 10th/50th/90th percentiles, 95% CI for mean (normal approx).
+5) Survival curve:
+   For t_grid_hours = 0..max(TTE) in 0.25h increments,
+   estimate S(t)=P(TTE > t) empirically.
+
+DELIVERABLES:
+A) UQ_SUMMARY_v1 (JSON): mean, std, p10, p50, p90, CI95_low, CI95_high
+B) SURVIVAL_CURVE_v1 (CSV): t_hours, S(t)
+C) REPRODUCIBILITY_v1 (JSON): seed, M, θ, σ, dt
+
+VALIDATION:
+- Must have exactly M successful runs.
+- Survival curve must be non-increasing in t (else FAIL).
+
+OUTPUT FORMAT:
+JSON, CSV, JSON. No prose.
+
+TASK: Generate the FINAL_SUMMARY_v1 for the MCM/ICM technical report.
+
+INPUT DATA:
+- All results from Prompt 1 to Prompt 8 (Model specs, TTE Table, Sensitivity, Robustness, UQ Summary).
+
+DELIVERABLES:
+A) “TECHNICAL_HIGHLIGHTS_v1” List:
+   - Identify the 3 most critical physical trade-offs discovered (e.g., Signal Quality vs. Power, Low Temp vs. Internal Resistance).
+   - Quantify the TTE impact of the worst-case scenario vs. baseline.
+B) “MODEL_STRENGTHS_v1”:
+   - List 3 technical strengths of our methodology (e.g., CPL algebraic-differential nesting, RK4 stability, Sobol-based sensitivity).
+C) “EXECUTIVE_DATA_SNIPPET”:
+   - A concise paragraph summarizing: "Our model predicts a baseline TTE of [X]h, with a [Y]% reduction in extreme cold. UQ analysis confirms a 90% survival rate up to [Z]h..."
+D) “FUTURE_WORK_v1”:
+   - 2 specific ways to improve the model (e.g., dynamic SOH aging laws, 2D thermal distribution modeling).
+
+VALIDATION:
+- All numbers must match the previous outputs exactly (4.60h baseline, 2.78h poor signal, 3.15h cold).
+
+OUTPUT FORMAT:
+Markdown with clear headings. Use LaTeX for equations if needed. No additional prose.
+
+TASK: Perform a *surgical*, additive refinement of an existing academic paper on battery simulation to close three specific gaps:
+(1) Missing GPS power
+(2) Missing uncertainty quantification (Monte Carlo)
+(3) Static aging TTE that fails to reflect dynamic degradation
+
+CRITICAL REQUIREMENT (NON-NEGOTIABLE): PRESERVE EXISTING CONTENT INTEGRITY
+- You MUST NOT do broad edits, major rewrites, rephrasings, or restructuring of any previously generated sections.
+- You MUST NOT renumber existing sections or reorder headings.
+- You MUST NOT change the existing narrative flow; only add narrowly targeted content and minimal equation patches.
+- You MUST output only (a) minimal patches and (b) insert-ready new text blocks.
+- If you cannot anchor an insertion to an exact existing heading string from the provided paper, output ERROR with the missing heading(s) and STOP.
+
+INPUT DATA (use only the uploaded files):
+1) The official MCM Problem A PDF (for requirements language: GPS, uncertainty, aging).
+2) The current paper markdown (contains the existing model and structure).
+3) The flowchart markdown (contains intended technical pipeline elements, e.g., UQ).
+
+MODEL CONTEXT YOU MUST RESPECT (do NOT rewrite these; only refer to them):
+- Existing input vector u(t) = [L(t), C(t), N(t), Ψ(t), T_a(t)] and state x(t) = [z, v_p, T_b, S, w].
+- Existing power mapping: P_tot = P_bg + P_scr(L) + P_cpu(C) + P_net(N,Ψ,w).
+- Existing CPL closure and event-based TTE logic.
+- Existing SOH concept S(t) and its coupling to R0 and Q_eff (if present).
+- Existing section numbering and headings.
+
+YOUR OBJECTIVES:
+A) CLASSIFY each gap by whether it requires changes to the base Model Construction:
+   - “Base Model Construction” includes: core equations, constitutive relations, or simulation logic required to run the model.
+B) For gaps NOT requiring base model changes, generate insert-ready academic text immediately (no rewrites).
+C) For gaps requiring base model changes, produce:
+   - A minimal patch (equations/logic) expressed as a precise replace/insert instruction.
+   - A small, insert-ready text addendum describing the change (ONLY the new material; do not rewrite existing paragraphs).
+
+METHODOLOGY (must be followed in order, no deviations):
+
+STEP 1 — Locate anchors in the existing paper
+1. Read the current paper markdown.
+2. Extract the exact heading strings (verbatim) for:
+   - The power mapping section (where P_tot is defined).
+   - The numerical solution / simulation section (where MC/UQ would be placed).
+   - The aging/SOH discussion section (or closest related section).
+3. Store these verbatim headings as ANCHORS. You will reference them in patch instructions.
+
+STEP 2 — Gap classification (deterministic)
+For each gap in {GPS, UQ, Aging-TTE} output:
+- requires_equation_change: true/false
+- requires_simulation_logic_change: true/false
+- text_only_addition: true/false
+Rules:
+- If adding a new term inside P_tot changes an equation, requires_equation_change=true.
+- If adding an outer-loop procedure for multi-cycle degradation is needed, requires_simulation_logic_change=true.
+- If content is purely reporting/analysis based on existing outputs (e.g., Monte Carlo over parameters/inputs using the same ODEs), then text_only_addition=true and both “requires_*” flags must be false.
+
+STEP 3 — Minimal patch design (ONLY if required)
+You must keep changes minimal and local:
+3.1 GPS Power gap:
+- Add exactly ONE GPS term into the existing P_tot equation.
+- Preferred minimal strategy: do NOT change the declared input vector; define a derived duty variable G(t) inside the new GPS subsection:
+  G(t) ∈ [0,1] derived from existing usage signals (e.g., navigation segment proxy) without redefining u(t).
+- Define:
+  P_gps(G) = P_gps,0 + k_gps * G(t)
+  and update:
+  P_tot ← P_tot + P_gps(G)
+- Do not edit any other power terms.
+3.2 Dynamic aging TTE gap:
+- Do NOT rewrite the base ODEs unless absolutely necessary.
+- Add an outer-loop “multi-cycle / multi-day” procedure that updates S(t) (or the aging proxy) across cycles and recomputes TTE each cycle:
+  Example logic: for cycle j, run discharge simulation → accumulate throughput/aging integral → update S_{j+1} → update R0 and Q_eff via existing formulas → recompute TTE_{j+1}.
+- Keep the inner single-discharge model unchanged; only add the outer-loop logic and clearly state time-scale separation.
+
+STEP 4 — Insert-ready academic text blocks (additive only)
+Generate concise academic prose that matches the paper’s existing style (math-forward, mechanistic rationale).
+Rules:
+- Each text block MUST be insertable without editing other sections.
+- Each text block MUST define any new symbol it uses (e.g., G(t), P_gps,0, k_gps).
+- Each text block MUST explicitly reference existing variables (L,C,N,Ψ,T_a,z,v_p,T_b,S,w,P_tot) without renaming.
+- Citations: use placeholder citations like [REF-GPS-POWER], [REF-MONTE-CARLO], [REF-LIION-AGING] (do not browse the web).
+
+You must produce 3 blocks:
+BLOCK A (GPS): a new subsection placed immediately after the existing network power subsection (anchor it precisely).
+BLOCK B (UQ): a new subsection placed in the numerical methods/results pipeline area describing Monte Carlo uncertainty quantification:
+  - Define what is random (choose ONE: stochastic parameter draws OR stochastic usage paths OR both).
+  - Specify sample size M (fixed integer), fixed seed, and outputs: mean TTE, quantiles, survival curve P(TTE>t).
+  - Emphasize: model equations unchanged; uncertainty comes from inputs/parameters.
+BLOCK C (Dynamic aging TTE): a new subsection explaining aging-aware TTE as a function of cycle index/time:
+  - Define TTE_j sequence across cycles.
+  - Define which parameters drift with S (e.g., Q_eff decreases, R0 increases).
+  - Provide a short algorithm listing (numbered) but no code.
+
+STEP 5 — Output packaging in strict schemas (no extra commentary)
+
+DELIVERABLES (must be EXACTLY in this order):
+
+1) GAP_CLASSIFICATION_v1 (JSON only)
+Schema:
+{
+  "GPS_power": {
+    "requires_equation_change": <bool>,
+    "requires_simulation_logic_change": <bool>,
+    "text_only_addition": <bool>,
+    "one_sentence_rationale": "<...>"
+  },
+  "UQ_monte_carlo": { ...same keys... },
+  "Aging_dynamic_TTE": { ...same keys... }
+}
+
+2) PATCH_SET_v1 (YAML only)
+- Provide a list of patches. Each patch must be one of:
+  - INSERT_AFTER_HEADING
+  - REPLACE_EQUATION_LINE
+Each patch item schema:
+- patch_id: "P10-..."
+- patch_type: "INSERT_AFTER_HEADING" or "REPLACE_EQUATION_LINE"
+- anchor_heading_verbatim: "<exact heading text from the paper>"
+- target_snippet_verbatim: "<exact single line to replace>"   (only for REPLACE_EQUATION_LINE)
+- replacement_snippet: "<new single line>"                    (only for REPLACE_EQUATION_LINE)
+- insertion_block_id: "BLOCK_A" / "BLOCK_B" / "BLOCK_C"        (only for INSERT_AFTER_HEADING)
+
+3) INSERT_TEXT_BLOCKS_v1 (Markdown only)
+Provide exactly three blocks, each wrapped exactly as:
+-----BEGIN BLOCK_A-----
+<markdown text to insert>
+-----END BLOCK_A-----
+(and similarly BLOCK_B, BLOCK_C)
+
+4) MODIFICATION_AUDIT_v1 (JSON only)
+Schema:
+{
+  "edited_existing_text": false,
+  "changed_headings_or_numbering": false,
+  "patch_ids_emitted": ["..."],
+  "notes": "Only additive blocks + minimal equation line replace (if any)."
+}
+
+VALIDATION (hard fail rules):
+- If you modify any existing paragraph (beyond the exact single-line equation replacement explicitly listed), output FAIL.
+- If you renumber headings or propose reorganization, output FAIL.
+- If any new symbol is introduced without definition inside its block, output FAIL.
+- If any anchor_heading_verbatim does not exactly match a heading in the paper, output ERROR and STOP.
+
+OUTPUT FORMAT:
+Return exactly the 4 deliverables above (JSON, YAML, Markdown, JSON) and nothing else.