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

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 - IR0(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/(R1C1) (E) Thermal ODE: dT_b/dt = ( I^2R0 + Iv_p - hA*(T_b - T_a) ) / C_th (F) Tail ODE: dw/dt = (σ(N)-w)/τ(N) with τ_up, τ_down switching rule (G) CPL closure: R0I^2 - (V_oc(z)-v_p)I + P_tot = 0 I = (V_oc(z)-v_p - sqrt(Δ)) / (2R0) Δ = (V_oc(z)-v_p)^2 - 4R0P_tot (H) V_oc(z) (modified Shepherd): V_oc(z)=E0 - K(1/z - 1) + Aexp(-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 - IR0(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/(R1C1) (E) Thermal ODE: dT_b/dt = ( I^2R0 + Iv_p - hA*(T_b - T_a) ) / C_th (F) Tail ODE: dw/dt = (σ(N)-w)/τ(N) with τ_up, τ_down switching rule (G) CPL closure: R0I^2 - (V_oc(z)-v_p)I + P_tot = 0 I = (V_oc(z)-v_p - sqrt(Δ)) / (2R0) Δ = (V_oc(z)-v_p)^2 - 4R0P_tot (H) V_oc(z) (modified Shepherd): V_oc(z)=E0 - K(1/z - 1) + Aexp(-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": , "requires_simulation_logic_change": , "text_only_addition": , "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: ""
• target_snippet_verbatim: "" (only for REPLACE_EQUATION_LINE)
• replacement_snippet: "" (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----- -----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.