dsh-aris-panel 0.1.0

package/skills/proof-orchestrator/references/dispatch-prompts.md

@@ -0,0 +1,227 @@
+# Local-First Proof Pipeline Prompts
+
+Use these templates for the local-first pipeline. Manual GPT Pro handoff is the
+default escalation route. Do not operate a browser or spend API credit unless
+the user explicitly asks executor to do so for the current run.
+
+## Local Proof Prompt
+
+```text
+Use $proof-orchestrator to attempt this proof locally before preparing any GPT
+Pro handoff.
+
+Run directory:
+prompts/<YYMMDDHH-num>/
+
+Target:
+[exact theorem, lemma, disproof, or diagnosis]
+
+Inputs:
+- [source path]: [authoritative role]
+
+Requirements:
+- Check assumptions, domains, boundary cases, quantifiers, and imported theorem
+  hypotheses.
+- Write the complete attempt to local-proof.md.
+- If it succeeds, audit correctness and edit the proof for clarity and minimal
+  notation before writing final.md.
+- Apply references/notation-audit.md and record its required metrics in
+  audit.md. Undefined symbols and symbol collisions must be zero.
+- If induction is used, expose the base case, induction hypothesis, and
+  induction step wherever needed for verification.
+- Present every nontrivial derivation top-down: state the target, justify its
+  reduction to immediate subgoals, derive each subgoal from named inputs, and
+  recombine them to close the target.
+- If it fails, isolate the smallest unresolved obligation. Do not call GPT Pro
+  or create remote project state.
+```
+
+## Continuation Prompt
+
+```text
+Use $proof-orchestrator to continue this proof project locally from the prior
+run.
+
+Prior run directory:
+prompts/<YYMMDDHH-num>/
+
+Continuation request:
+[one narrow obligation]
+
+Requirements:
+- Read the prior final.md, audit.md, local-proof.md, codex-ledger.md,
+  source-manifest.md, handoff.md, and any next/redo/continuation files that
+  exist.
+- Create a new run directory and record the prior run ID and exact files read.
+- Inherit only audited claims; treat raw GPT Pro output as evidence.
+- Reuse stable local sources without overwriting the prior run.
+- Attempt the current obligation locally before preparing a new GPT Pro prompt.
+- If escalation is still needed, use a new browser prompt and a fresh GPT Pro
+  conversation.
+```
+
+## Manual GPT Pro Handoff Prompt
+
+```text
+Use $proof-orchestrator to prepare a manual GPT Pro handoff for the blocker in
+this run. Do not call GPT Pro, control a browser, upload files, or spend API
+credit.
+
+Run directory:
+prompts/<YYMMDDHH-num>/
+
+Required inputs:
+- local-proof.md
+- task.md and materials.md when present
+- relevant files under sources/
+
+Outputs:
+- source-manifest.md
+- browser-prompt.md
+- handoff.md
+
+Requirements:
+- Ask only for the smallest unresolved proof obligation.
+- Give every source a stable browser-visible filename and state whether it must
+  be uploaded separately.
+- Make browser-prompt.md the exact self-contained text the user can paste. Keep
+  local paths and route bookkeeping out of it.
+- Ask GPT Pro to label added assumptions, imported results, conjectures, and
+  unsupported claims.
+- Require END_GPT_PRO_OUTPUT as the final output line.
+- In handoff.md, list the upload order, then the prompt-copy step, then where the
+  user should return or save the output.
+- Mark READY_FOR_MANUAL_GPT_PRO and wait for the user.
+```
+
+## Optional DeepSeek Second-Opinion Prompt
+
+Use this template only when the user explicitly requests DeepSeek review or an
+independent second opinion for the current proof run:
+
+```text
+Use $proof-orchestrator's optional DeepSeek audit branch for this run.
+
+Run directory:
+prompts/<YYMMDDHH-num>/
+
+Inputs:
+- task.md and materials.md
+- local-proof.md
+- authoritative files under sources/
+
+Requirements:
+- Complete the local obligation ledger first.
+- Read references/proof-audit-rubric.md and references/deepseek-routing.md.
+- Use only the declared llm-chat DeepSeek route; do not invent credentials or
+  silently substitute another remote model.
+- Save raw reviewer output to deepseek-review.md.
+- Verify issue locations and counterexamples locally before integrating them.
+- Write the checked verdict to audit.md using
+  references/audit-output-contract.md.
+- If the route is unavailable, mark DEEPSEEK_REVIEW_BLOCKED; a local fallback
+  is not independent cross-family acceptance.
+```
+## Explicit executor Dispatch Prompt
+
+Use this template only after the user explicitly asks executor to perform the
+current GPT Pro call:
+
+```text
+The user has explicitly authorized executor to dispatch this prepared GPT Pro
+handoff for the current run.
+
+Run directory:
+prompts/<YYMMDDHH-num>/
+
+Requirements:
+- Mark READY_FOR_CODEX_DISPATCH.
+- Load $call-gpt-pro and confirm the selected web or API route, source-upload
+  scope, and any API spending authority.
+- Use browser-prompt.md as the exact model-facing prompt and source-manifest.md
+  as the source contract.
+- Do not silently switch routes if browser access fails.
+- Save the complete answer to gpt-pro-output.md and follow the requested end
+  marker and completion checks.
+```
+
+## Returned Proof Audit and Edit Prompt
+
+```text
+Use $proof-orchestrator to audit and edit the returned GPT Pro proof.
+
+Run directory:
+prompts/<YYMMDDHH-num>/
+
+Inputs:
+- gpt-pro-output.md
+- local-proof.md
+- source-manifest.md and the authoritative local sources
+
+Outputs:
+- audit.md
+- final.md only if the audited result is usable
+
+Correctness pass:
+- Check hidden assumptions, quantifiers, constants, boundary cases, imported
+  theorem hypotheses, and whether each conclusion follows from the sources.
+- Label proved, imported, conjectural, repaired, and unsupported claims.
+
+Exposition pass after correctness:
+- Lead with the conclusion and retain every non-obvious logical step.
+- Present nontrivial derivations top-down: say why the target follows from the
+  immediate subgoals before deriving them, state where each subgoal comes from,
+  and explicitly recombine them to conclude the target.
+- Make induction structure explicit where needed.
+- Remove redundant or immediate steps only when no dependency is lost.
+- Delete unused notation, collapse needless aliases, and simplify subscripts.
+- Prefer the shortest clear proof, not the shortest-looking proof.
+- Identify the theorem's core state, policy or distribution, operator,
+  objective, and dependency direction before simplifying. Coordinates may
+  shorten calculations but must not replace core objects in main conclusions.
+- Apply references/notation-audit.md and copy its exact seven-line scorecard into
+  audit.md. Do not rename or replace the metrics with an informal summary.
+- Do not write READY_FOR_USER while a notation blocker remains. Fix or justify
+  every warning threshold in audit.md.
+
+If a central gap remains, mark NEEDS_GPT_PRO_REDO and prepare a focused manual
+redo prompt. Do not dispatch it through executor without new explicit user
+authorization.
+```
+
+## GPT Pro Output Repair Prompt
+
+```text
+Use $proof-orchestrator to repair copy corruption in gpt-pro-output.md before
+the correctness audit.
+
+Requirements:
+- Preserve proof order, labels, claims, constants, assumptions, and theorem
+  status.
+- Confirm END_GPT_PRO_OUTPUT when it was requested.
+- Balance display-math delimiters and repair only unambiguous escaped-brace,
+  operator, separator, or Markdown corruption.
+- Flag ambiguous damage in audit.md instead of guessing.
+- Put substantive clarity and notation edits in final.md after correctness has
+  been audited.
+```
+
+## Focused Redo Prompt
+
+```text
+Prepare a manual GPT Pro redo package from the audited gap.
+
+Inputs:
+- local-proof.md
+- gpt-pro-output.md
+- audit.md
+- source-manifest.md
+
+Requirements:
+- Ask only for the audited missing step or invalid inference.
+- Preserve the original theorem and assumptions.
+- Update browser-prompt.md, source-manifest.md, and handoff.md.
+- Default to READY_FOR_MANUAL_GPT_PRO.
+- Do not let executor dispatch the redo unless the user explicitly asks it to do
+  so for this turn.
+```

package/skills/proof-orchestrator/references/notation-audit.md

@@ -0,0 +1,135 @@
+# Proof Notation Audit
+
+Apply this audit after correctness checking and before writing `final.md`.
+Treat the thresholds as editing gates, not mathematical laws. Keep a warning
+only when the notation genuinely shortens the proof, and record why.
+
+## Required Inventory
+
+First identify the semantic center from the theorem statement, algorithm
+update, and final conclusion: the state variable, policy or distribution,
+operator, objective, and their dependency direction. Then record each
+nonstandard symbol's meaning, scope, first definition, and number of later uses.
+Classify it as `core`, `keep`, `localize`, `inline`, `rename`, or `delete`.
+Exclude bound variables, summation indices, and standard operators.
+
+Report these seven metrics in `audit.md` with the exact labels and order below.
+Do not substitute related measures such as "overloaded symbols," "irrelevant
+chains," or a prose summary:
+
+```text
+Core semantic objects retained: <retained>/<declared> (<percent>)
+Undefined symbols: <count>
+Symbol collisions: <count>
+One-use definitions: <count>/<all new symbols> (<percent>)
+Maximum parallel representations of one object: <count>
+Maximum alias-chain depth: <count>
+Maximum active nonstandard symbols in one proof step: <count>
+```
+
+## Blocking Rules
+
+Do not mark `READY_FOR_USER` unless core-object retention is 100% and both
+counts below are zero:
+
+- **Core-object loss:** a rewrite deletes, hides, or replaces a theorem's
+  central state, policy or distribution, operator, objective, or dependency
+  direction. A coordinate chart is not a substitute for the object it
+  parameterizes.
+
+- **Undefined symbol:** a symbol appears before its meaning and scope are clear.
+- **Collision:** the same glyph denotes different objects anywhere in the
+  artifact. Different subscripts do not cure a changed base meaning.
+
+Prefer the established or standard meaning. Rename or remove the other use.
+Do not rely on distant section boundaries to make a collision harmless.
+
+Keep local coordinates only when they reduce calculations. State their map to
+the core object at first use, and express every main theorem, flow, or final
+bound again through the core object. Fewer glyphs do not compensate for a
+changed mathematical interface.
+
+Do not reduce blocker counts by supplying plausible missing mathematics. A
+notation rewrite may rename or inline supported expressions, but it must not
+invent a domain, assumption, derivative identity, sign relation, theorem
+hypothesis, or definition. Leave an unresolved item in the scorecard and mark
+the proof unusable until authoritative material resolves it.
+
+## Warning Thresholds
+
+### Definition Payoff
+
+Keep a new symbol only if at least one condition holds:
+
+- it appears in three or more later formulas;
+- it appears in both a theorem statement and its proof;
+- it names an object that the prose compares, varies, or cites later.
+
+Inline an expression of roughly 12 characters or fewer when it appears at most
+twice. A local abbreviation may remain when expanding it would obscure a long
+derivation, but its scope must end with that derivation.
+
+### One-Use Definitions
+
+- Good: at most 10% of new symbols.
+- Warning: more than 10% and at most 20%.
+- Bad: more than 20%.
+
+A one-use definition appears only in the immediately following sentence or
+formula. Do not count bound variables or standard local placeholders.
+
+### Parallel Representations
+
+- Good: at most two persistent representations per object, such as a
+  probability and its logit.
+- Bad: three or more persistent representations.
+
+Permit a third representation only inside one local derivation. Remove it when
+the subsection ends.
+
+### Alias-Chain Depth
+
+- Good: one layer; a symbol refers directly to the original quantities.
+- Warning: two layers.
+- Bad: three or more layers.
+
+Flatten chains such as `K := M+2`, `lambda := a/K`, `S := lambda x+b`, when the
+last alias serves only one inequality.
+
+### Active Symbol Load
+
+Count the nonstandard symbols a reader must remember across one theorem
+statement, proof paragraph, or uninterrupted formula chain.
+
+- Good: at most 8.
+- Warning: 9--12.
+- Bad: more than 12.
+
+When the count exceeds 8, split the argument, localize definitions, or inline
+temporary aliases. Do not remove proof steps merely to lower the count.
+
+### Definition Distance
+
+Define a symbol within the paragraph before its first use. End local symbol
+scope at the subsection boundary. A reader should not need to cross a section
+boundary to recover a definition unless the symbol belongs to the theorem's
+declared global notation.
+
+## Rewrite Order
+
+1. Identify and freeze the semantic center and dependency direction.
+2. Fix undefined symbols and collisions.
+3. Delete unused non-core symbols.
+4. Inline one-use definitions and flatten alias chains.
+5. Limit persistent representations of each object.
+6. Split steps whose active symbol load remains above 8.
+7. Map coordinate conclusions back to the core objects.
+8. Recheck every substitution and theorem dependency.
+9. Only then remove redundant prose or obvious algebra.
+
+If a shorter rewrite would require a new mathematical relation, output a
+diagnosis rather than a repaired proof.
+
+Preserve a longer expression when a new name carries mathematical meaning.
+Never trade correctness or a verifiable non-obvious step for a lower symbol
+count.

package/skills/proof-orchestrator/references/proof-audit-rubric.md

@@ -0,0 +1,70 @@
+# Adversarial Proof Audit Rubric
+
+Use this rubric only after locating the exact proof and its dependencies.
+
+## Issue Taxonomy
+
+- `UNJUSTIFIED_ASSERTION`: a step lacks proof or a cited result.
+- `UNPROVEN_SUBCLAIM`: a "clear" or "standard" step hides a nontrivial lemma.
+- `QUANTIFIER_ERROR`: wrong order of forall/exists, missing sufficiently-small parameter scope, or hidden dependence.
+- `IMPLICATION_REVERSAL`: uses one direction as an equivalence.
+- `CASE_INCOMPLETE`: omits boundary, degenerate, zero, singular, or non-unique cases.
+- `CIRCULAR_DEPENDENCY`: proof uses the target theorem or a downstream consequence.
+- `ILLEGAL_INTERCHANGE`: swaps limit, expectation, derivative, integral, supremum, or infimum without conditions.
+- `MISSING_DOMINATION`: invokes DCT, Leibniz, or differentiation under the integral without a dominating function.
+- `INTEGRABILITY_GAP`: uses a moment, norm, or expectation not assumed or proved finite.
+- `REGULARITY_GAP`: uses continuity, differentiability, convexity, compactness, measurability, or Lipschitzness without support.
+- `STOCHASTIC_MODE_CONFUSION`: changes among almost surely, in probability, in expectation, high probability, or Lp without proof.
+- `HIDDEN_ASSUMPTION`: relies on conditions not in the statement.
+- `INSUFFICIENT_ASSUMPTION`: stated hypotheses are too weak for the claimed result.
+- `DIMENSION_TRACKING`: constants or rates hide dependence on dimension, horizon, sample size, components, or other parameters.
+- `NORMALIZATION_MISMATCH`: inconsistent scaling, coordinate convention, or notation.
+- `SCOPE_OVERCLAIM`: conclusion is broader than the proof supports.
+- `REFERENCE_MISMATCH`: cited result's hypotheses are not verified.
+
+## Severity
+
+- `FATAL`: statement is false or contradicted, and the main theorem or core dependency breaks.
+- `CRITICAL`: a global proof obligation is unjustified, or a local statement is invalid.
+- `MAJOR`: a local proof obligation is unjustified, or a global claim needs weakened conclusion or stronger assumptions.
+- `MINOR`: notation, exposition, or bookkeeping issue that does not change the mathematics.
+
+## Mandatory Checks
+
+For every theorem, lemma, proposition, and proof:
+
+1. Definitions: list symbols whose meaning, type, or domain changes.
+2. Hypothesis discharge: at each application of a lemma or theorem, verify every hypothesis at that point.
+3. Inequalities: check direction, absolute values, PSD or convexity assumptions, norm compatibility, and equality cases.
+4. Interchanges: verify conditions for DCT, MCT, Fubini/Tonelli, Leibniz, Taylor remainder, implicit function theorem, envelope theorem, or minimax exchange.
+5. Probability mode: track whether each convergence or bound is almost sure, in probability, in expectation, high probability, or Lp.
+6. Uniformity and constants: make every O/o/Theta and hidden constant declare its parameter dependence and uniformity scope.
+7. Edge cases: test zero weights, singular matrices, non-unique optima, boundary parameters, d=1, K=1 or K=2, small n, and extreme scaling.
+8. Dependency consistency: detect circularity, forward references, and unproved prerequisites.
+9. Conclusion match: confirm the last line proves exactly the stated conclusion, with the same quantifiers and constants.
+
+## Common Side Conditions
+
+- DCT: pointwise a.e. convergence and an integrable dominating function.
+- MCT: monotone nonnegative sequence or functions.
+- Fubini: product measurability and absolute integrability.
+- Tonelli: product measurability and nonnegativity.
+- Leibniz rule: differentiability plus domination of derivative or a suitable theorem-specific condition.
+- Jensen: convexity or concavity in the correct direction and integrability.
+- Cauchy-Schwarz: valid inner product or norm space and finite second moments.
+- Taylor expansion: stated differentiability order and explicit remainder control.
+- WLOG: reversible transformation or invariant problem class.
+
+## Counterexample Discipline
+
+Mark `counterexample found` only after algebraic verification. Otherwise use
+`counterexample candidate` and explain what remains to check.
+
+Useful attempts:
+
+- collapse to one dimension;
+- set matrices singular, diagonal, rank one, or identity;
+- make weights zero, nearly zero, or equal;
+- force overlapping parameters or non-identifiability;
+- choose two-point, heavy-tailed, or boundary distributions;
+- let hidden constants grow with the supposedly uniform parameter.

package/skills/proof-orchestrator/references/stress-tests.md

@@ -0,0 +1,38 @@
+# External Review Stress Tests
+
+User-operated manual browser handoff is the default for proof-orchestrator
+stress tests; the executor never operates a browser.
+First complete the local attempt and isolate the exact obligation being tested.
+
+For every test:
+
+1. Create a fresh local run directory.
+2. Keep only the required source snapshots under `sources/` and record them in
+   `source-manifest.md`.
+3. Prepare `browser-prompt.md` as exact copy-ready text and `handoff.md` as the
+   user-facing upload/paste instructions.
+4. Use a fresh ChatGPT Project for an unrelated test. A direct continuation may
+   reuse a Project only when the source set still matches, and must use a new
+   conversation.
+5. Save the returned text as `gpt-pro-output.md`, then run correctness and
+   exposition passes separately.
+
+If a test names PDFs or other primary documents, mark them as required separate
+uploads in `source-manifest.md`. Do not silently replace them with extracted
+text, memory, or a bundle.
+
+Only when the user explicitly asks executor to perform the dispatch should executor
+load `call-gpt-pro` and follow its selected-route instructions. A failed browser
+route is not authorization to spend API credit.
+## DeepSeek Route Tests
+
+- With no explicit DeepSeek request, complete the local pipeline without a
+  remote reviewer and without creating `deepseek-review.md`.
+- With an explicit DeepSeek second-opinion request and an available llm-chat
+  route, save raw output, validate issue locations and counterexamples, and
+  integrate only checked findings into `audit.md`.
+- With an explicit request but no available route, mark
+  `DEEPSEEK_REVIEW_BLOCKED`; label any local audit as a fallback and do not
+  claim independent acceptance.
+- Never redirect existing paper workflows from `/proof-checker` to this optional
+  branch.

package/skills/proof-writer/SKILL.md

@@ -0,0 +1,223 @@
+---
+name: proof-writer
+description: Writes rigorous mathematical proofs for ML/AI theory. Use when asked to prove a theorem, lemma, proposition, or corollary, fill in missing proof steps, formalize a proof sketch, 补全证明, 写证明, 证明某个命题, or determine whether a claimed proof can actually be completed under the stated assumptions.
+argument-hint: "[theorem-statement-and-assumptions]"
+allowed-tools: Read, Write, Edit, Grep, Glob
+---
+
+# Proof Write: Rigorous Theorem / Lemma Drafting
+
+Write a mathematically honest proof package, not a polished fake proof.
+
+## Constants
+
+- DEFAULT_PROOF_DOC = `PROOF_PACKAGE.md` in project root
+- STATUS = `PROVABLE AS STATED | PROVABLE AFTER WEAKENING / EXTRA ASSUMPTION | NOT CURRENTLY JUSTIFIED`
+
+## Context: $ARGUMENTS
+
+## Goal
+
+Produce exactly one of:
+1. a complete proof of the original claim
+2. a corrected claim plus a proof of the corrected claim
+3. a blockage report explaining why the claim is not currently justified
+
+## Inputs
+
+Extract and normalize:
+- exact theorem / lemma / proposition / corollary statement
+- explicit assumptions
+- notation and definitions
+- any user-provided proof sketch, partial proof, or intended strategy
+- nearby lemmas or claims in local notes, appendix files, or theorem drafts if the request points to them
+- desired output style if specified: concise, appendix-ready, or full-detail
+
+If notation or assumptions are ambiguous, state the exact interpretation you are using before proving anything.
+
+## Workflow
+
+### Step 1: Gather Proof Context
+Determine the target proof file with this priority:
+1. a file path explicitly specified by the user
+2. a proof draft already referenced in local notes or theorem files
+3. `PROOF_PACKAGE.md` in project root as the default target
+
+Read the relevant local context:
+- the chosen target proof file, if it already exists
+- theorem notes, appendix drafts, or files explicitly mentioned by the user
+
+Extract:
+- exact claim
+- assumptions
+- notation
+- proof sketch or partial proof
+- nearby lemmas that the draft may depend on
+
+### Step 2: Normalize the Claim
+Restate:
+- the exact claim being proved
+- all assumptions, separately from conclusions
+- all symbols used in the claim
+
+Identify:
+- hidden assumptions
+- undefined notation
+- scope ambiguities
+- whether the available sketch proves the full claim or only a weaker variant
+
+Preserve the user's original theorem statement unless a change is explicitly required.
+If you use a stronger normalization or cleaner internal formulation only to make the proof easier, keep that as an internal proof device rather than silently replacing the original claim.
+
+### Step 3: Feasibility Triage
+Before writing a proof, classify the claim into exactly one status:
+- `PROVABLE AS STATED`
+- `PROVABLE AFTER WEAKENING / EXTRA ASSUMPTION`
+- `NOT CURRENTLY JUSTIFIED`
+
+Check explicitly:
+- does the conclusion actually follow from the listed assumptions?
+- is any cited theorem being used outside its conditions?
+- is the claim stronger than what the available argument supports?
+- is there an obvious counterexample, boundary case, or quantifier failure?
+
+If the claim is not provable as stated, do NOT fabricate a proof.
+Do NOT silently strengthen assumptions or narrow the theorem's scope just to make the proof work.
+
+### Step 4: Build a Dependency Map
+Choose a proof strategy, for example:
+- direct
+- contradiction
+- induction
+- construction
+- reduction to a known result
+- coupling / probabilistic argument
+- optimization inequality chaining
+
+Then write a dependency map:
+- main claim
+- required intermediate lemmas
+- named theorems or inequalities that will be cited
+- which assumptions each nontrivial step depends on
+- boundary cases that must be handled separately
+
+If one step is substantial, isolate it as a lemma instead of burying it in one sentence.
+
+### Step 5: Write the Proof Document
+Write to the chosen target proof file.
+
+If the target proof file already exists:
+- read it first
+- update the relevant claim section
+- do not blindly duplicate prior content
+
+If the user does not specify a target, default to `PROOF_PACKAGE.md` in project root.
+
+Do NOT write directly into paper sections or appendix `.tex` files unless the user explicitly asks for that target.
+
+The proof package must include:
+- exact claim
+- explicit assumptions
+- proof status
+- announced strategy
+- dependency map
+- numbered major steps
+- justification for every nontrivial implication
+
+Mathematical rigor requirements:
+- never use "clearly", "obviously", "it can be shown", "by standard arguments", or "similarly" to hide a gap
+- define every constant and symbol before use
+- check quantifier order carefully
+- handle degenerate and boundary cases explicitly, or state why they are excluded
+- if invoking a standard fact, state its name and why its assumptions are satisfied here
+- use `$...$` for inline math and `$$...$$` for display equations
+- never write math in plain text
+- if the proof uses an equivalent normalization that is stronger in appearance than the user's original theorem statement, label it explicitly as a proof device and keep the original claim separate
+
+### Step 6: Final Verification
+Before finishing the target proof file, verify:
+- the theorem statement exactly matches what was actually shown
+- every assumption used is stated
+- every nontrivial implication is justified
+- every inequality direction is correct
+- every cited result is applicable under the stated assumptions
+- edge cases are handled or explicitly excluded
+- no hidden dependence on an unproved lemma remains
+
+If a key step still cannot be justified, downgrade the status and write a blockage report instead of forcing a proof.
+
+## Required File Structure
+
+Write the target proof file using this structure:
+
+```md
+# Proof Package
+
+## Claim
+[exact statement]
+
+## Status
+PROVABLE AS STATED / PROVABLE AFTER WEAKENING / NOT CURRENTLY JUSTIFIED
+
+## Assumptions
+- ...
+
+## Notation
+- ...
+
+## Proof Strategy
+[chosen approach and why]
+
+## Dependency Map
+1. Main claim depends on ...
+2. Lemma A depends on ...
+3. Step k uses ...
+
+## Proof
+Step 1. ...
+Step 2. ...
+...
+Therefore the claim follows. ∎
+
+## Corrections or Missing Assumptions
+- [only if needed]
+
+## Open Risks
+- [remaining fragile points, if any]
+```
+
+## Output Modes
+
+### If the claim is provable as stated
+Write the full file structure above with a complete proof.
+
+### If the original claim is too strong
+Write:
+- why the original statement is not justified
+- the corrected claim
+- the minimal extra assumption if one exists
+- a proof of the corrected claim
+
+### If the proof cannot be completed honestly
+Write:
+- `Status: NOT CURRENTLY JUSTIFIED`
+- the exact blocker: missing lemma, invalid implication, hidden assumption, or counterexample direction
+- what extra assumption, lemma, or derivation would be needed to finish the proof
+- a corrected weaker statement if one is available
+
+## Chat Response
+
+After writing the target proof file, respond briefly with:
+- status
+- whether the original claim survived unchanged
+- what file was updated
+
+## Key Rules
+
+- Never fabricate a missing proof step.
+- Prefer weakening the claim over overclaiming.
+- Separate assumptions, derived facts, heuristics, and conjectures.
+- Preserve the user's original theorem statement unless you explicitly mark a corrected claim or an internal normalization.
+- If the statement is false as written, say so explicitly and give a counterexample or repaired statement.
+- If uncertainty remains, mark it explicitly in `Open Risks`; do not hide it inside polished prose.
+- Correctness matters more than brevity.