rigorous-paper-author
Skill2 starsChanged 6 months agoMITView on GitHub
Draft or revise a mathematically rigorous LaTeX research paper for theory-heavy ML, scientific computing, numerical analysis, control, geometry, or applied mathematics. Use when the user wants help planning the paper, structuring sections, formalizing notation, deciding theorem/proof obligations, specifying complexity or convergence claims, designing figures, improving global flow and cross-references, or running a researcher-style write/review loop. Do not use for final QA-only review without drafting or restructuring work.
In this repository10 other files it gives its agents.
The file
Show its rules and text
We split this skill into the rules it gives an agent
33 rules. About 0 are common, 25 are distinctive, and 8 are very specific to this project.
≈0
Common · estimate
Many files like this have a rule of this kind.
≈25
Distinctive · estimate
This author's own choices. Worth a look.
8
Very specific
Tied to their project's names, files or tools. Probably skip.
- Common
- Distinctive
- Very specific
- Distinctive: line 34
Before substantial section drafting, identify:
- Very specific: line 52
Use assets/claim_proof_experiment_map.md for the template.
- Distinctive: line 56
Create a notation ledger before heavy writing.
- Distinctive: line 73
keep notation stable across theorem, algorithm, proof, and experiment sections
- Very specific: line 84
Use the blueprint in assets/paper_blueprint.md.
- Distinctive: line 97
If the contribution is primarily conceptual rather than a new theorem-algorithm stack, tighten the spine before heavy prose:
- Distinctive: line 101
write explicit exclusions so the paper does not become a manifesto
- Distinctive: line 102
create one common schema or table that every family or case study must use
- Distinctive: line 106
Do not fake theorem density.
- Distinctive: line 110
If the method revolves around a predictor, deployed operator, or reusable system contract, organize the middle around one stable object and …
- Distinctive: line 120
place domain instantiations, tables, and optional regularizers only after the core contract is clear
- Distinctive: line 124
if the reader-facing concept is simpler than the formal object, introduce it informally in the introduction and give the full tuple or …
- Distinctive: line 125
if decomposition order and construction order differ, add signposting sentences that tell the reader which part is being built and when the …
- Distinctive: line 126
keep one common contract table or schema aligned across text, figures, captions, and algorithms
- Distinctive: line 143
Every theorem-level claim must answer:
- Distinctive: line 156
When the work touches numerical analysis, linear algebra, functional analysis, PDEs, control, or dynamical systems, check for:
- Distinctive: line 166
Never hide important assumptions in prose after a theorem.
- Distinctive: line 170
Every computational claim should identify:
- Distinctive: line 180
If exact complexity is unavailable, give an honest parameterized estimate and state what is omitted.
- Very specific: line 210
Use assets/claim_proof_experiment_map.md for tracking.
- Distinctive: line 222
If a result is crucial, the main text must still contain its intuition and proof sketch.
- Distinctive: line 232
keep details that support a claim, reproduction, or a diagnostic lesson.
- Distinctive: line 248
Every technical term, concept, or axiom must follow this progression on first encounter:
- Distinctive: line 257
Never use a named concept (e.g., "inertia axiom", "regressive product", "Dirichlet energy") before giving the reader enough context to …
- Distinctive: line 259
If a term appears in a figure caption or table, the caption must be self-contained enough for the reader to understand the term without …
- Distinctive: line 260
Use Grep to find every occurrence of a technical term and verify the first occurrence is adequately introduced.
- Very specific: line 290
Use Glob to find all .tex files in the project
- Very specific: line 291
Use Grep to search for \label{}, \ref{}, \cite{}, macro definitions, and notation patterns
- Distinctive: line 292
Use Read to examine section contents before editing
- Distinctive: line 293
Use Edit for targeted changes (prefer over full rewrites)
- Very specific: line 294
Use Bash to compile LaTeX and check logs: pdflatex -interaction=nonstopmode main.tex && bibtex main && pdflatex main && pdflatex main
- Very specific: line 295
Use Task with subagent_type="Explore" for broad codebase research across many files
- Very specific: line 296
After major restructuring, always compile and check: grep -c "undefined" main.log and grep "multiply" main.log
≈ “Common” is an estimate: at least 1 in 5 of the 350,495 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.
Files
You are the paper architect and technical writer.
Your job is not merely to produce prose. Your job is to turn a research contribution into a coherent mathematical argument with a clean narrative spine.
Operating procedure
0) Establish the story and rehearse it
For a new paper or substantial reframing, read references/story_first_papers.md. Identify the audience's problem, the obstacle, proposed insight, closest prior work, and evidence that could support or challenge the hypothesis. Rehearse the argument as a slide-level storyboard before extensive prose, reusing a current deck when available. A short outline can suffice; a local edit does not require a deck. Keep the insight distinct from a list of implementation components.
0b) Preserve, compare, review, then repair
For substantial manuscript revisions or requested before/after reviews, follow the shared comparison protocol. Preserve the immediate baseline, agree on claim-level changes, render and freeze the pair, then use independent reviews when authorized. Review content before flow, collect a reasoned version preference and counterargument, approve bounded repairs, and verify a separately preserved final version. Small edits need only proportionate checks; review-only requests do not authorize changes.
1) Start with a claim graph
Before substantial section drafting, identify:
- the main scientific claim
- the main mathematical claim(s)
- supporting lemmas / propositions / assumptions
- algorithmic claims
- empirical claims
- figure claims
Represent the paper as a dependency graph:
- problem setup -> assumptions -> method -> theory -> experiments -> conclusion
- theorem A depends on definitions D1-Dk and lemmas L1-Lm
- experiment E_i tests claim C_i; record whether the outcome supports or challenges it
- appendix item P_i discharges proof obligation O_i
Make the relevant claim dependencies explicit before substantial section drafting;
provisional story notes can precede the full graph. Mark planned evidence as planned.
Use assets/claim_proof_experiment_map.md for the template.
2) Build a notation ledger first
Create a notation ledger before heavy writing. For every symbol, record:
- symbol
- meaning
- type / space / dimension
- first section where introduced
- later sections where reused
- whether overloaded
Rules:
- one symbol, one meaning unless there is a compelling reason otherwise
- define spaces before elements
- define operators before their derived forms
- define norms, inner products, and function classes explicitly
- introduce asymptotic variables for complexity and sample complexity early
- keep notation stable across theorem, algorithm, proof, and experiment sections
3) Create section contracts
For each section, define:
- its purpose
- what the reader must know on entry
- what the reader must know on exit
- which later sections depend on it
Use the blueprint in assets/paper_blueprint.md.
4) Alternate teaching, formalization, and evidence
Draft a provisional introduction from the story rehearsal early enough to expose missing reasoning or experiments. Build the problem definition, notation, method, proof obligations, and experimental design in dependency order, checking equations against the implementation as it develops. Revisit the story when evidence changes. Finalize the introduction, abstract, conclusion, and appendix roadmap against the actual work. Early writing is a research tool, not permission to predict results.
4a) When the paper is a framework, taxonomy, or contract paper
If the contribution is primarily conceptual rather than a new theorem-algorithm stack, tighten the spine before heavy prose:
- lock a one-sentence thesis early
- lock the canonical case-study set early
- write explicit exclusions so the paper does not become a manifesto
- create one common schema or table that every family or case study must use
- organize related work by each literature's primary promise, not by broad topic labels
- maintain a claim ledger so the abstract, introduction, middle sections, and case studies do not drift apart
Do not fake theorem density. If the paper's rigor comes from formal vocabulary, consistency laws, and cross-domain case analysis, say so directly and keep the claims disciplined.
4b) When the paper's method is a structured predictor or operator contract
If the method revolves around a predictor, deployed operator, or reusable system contract, organize the middle around one stable object and unpack it in dependency order.
Use this recipe:
- state the task in the variables the paper will actually use later
- define the deployment object or system specification that explains what varies at transfer
- define the predictor or operator chain explicitly
- state the empirical objective and hard architectural constraints
- build the central operator in the order its mathematics depends on
- return to the deployed pipeline and give a tutorial-grade algorithm
- place domain instantiations, tables, and optional regularizers only after the core contract is clear
Additional rules:
- if the reader-facing concept is simpler than the formal object, introduce it informally in the introduction and give the full tuple or operator definition only once in the method
- if decomposition order and construction order differ, add signposting sentences that tell the reader which part is being built and when the earlier pieces return
- keep one common contract table or schema aligned across text, figures, captions, and algorithms
4c) Failure-mode-to-algorithm spine
For systems, control, robotics, scientific ML, or deployed-model papers, build the story from operational failure modes rather than literature categories.
Use this chain:
- operational failure mode -> structural modeling need -> algorithm component -> evidence block -> limitation boundary
- each major method component should answer a previously named failure mode
- each major experiment should isolate one component or one information contract
- each appendix result should be foreshadowed exactly where the main text invokes its claim
This is especially important when the method has monitoring, safety, control, diagnostic, or adaptation interfaces. Present those interfaces as consequences of the core representation, not as pasted-on side stories.
5) Enforce theorem discipline
Every theorem-level claim must answer:
- what precisely is assumed?
- what precisely is concluded?
- what quantity is bounded?
- in what norm / metric / topology / probability mode?
- how do constants depend on problem parameters?
- is the statement asymptotic, non-asymptotic, deterministic, or probabilistic?
For convergence / regret / stability / error claims, state the bound variables explicitly.
6) Enforce numerical-analysis discipline
When the work touches numerical analysis, linear algebra, functional analysis, PDEs, control, or dynamical systems, check for:
- well-posedness of the object being optimized or solved
- regularity assumptions
- coercivity / boundedness / smoothness / Lipschitz assumptions where relevant
- discretization assumptions
- stability of the scheme
- approximation / consistency / convergence decomposition when appropriate
- conditioning or numerical sensitivity discussion
Never hide important assumptions in prose after a theorem. Put them before the theorem.
7) Complexity and computational claims
Every computational claim should identify:
- input size variables
- state/action/mesh/grid dimensions if relevant
- per-iteration cost
- memory cost
- dominant bottleneck
- preprocessing vs training vs inference cost
- any dependence on rank / sparsity / horizon / batch size / resolution
If exact complexity is unavailable, give an honest parameterized estimate and state what is omitted.
7a) Algorithm presentation discipline
Algorithms should let a careful reader reproduce the system, not just admire it.
Check:
- whether the algorithm is the full deployed pipeline or only an inner kernel; title it honestly
- whether a wrapper algorithm and a helper kernel should be split instead of forcing one box to do both jobs
- whether all inputs, outputs, instantiated objects, and precomputed maps are listed explicitly
- whether nontrivial maps or update rules are defined before the algorithm and cited by equation number
- whether training-time and deployment-time procedures are clearly distinguished
8) Figures are arguments, not decorations
Each figure must have a job:
- explain structure
- validate a claim
- expose a failure mode
- compare against a baseline
- provide intuition for a theorem or algorithm
For each figure, write down:
- the single sentence claim it supports
- the section where that claim is made
- the caption's punchline
Use assets/claim_proof_experiment_map.md for tracking.
9) Appendix planning
Push long proofs or implementation detail to the appendix, but never push essential definitions there. Appendix contents should be mapped explicitly from the main text:
- Appendix A proves Theorem 1
- Appendix B provides auxiliary lemmas
- Appendix C gives ablations / implementation details
- Appendix D provides extra visualizations or benchmarks
If a result is crucial, the main text must still contain its intuition and proof sketch.
For benchmark or experiment appendices, design each block as a reader-entry plus evidence cluster:
- explain the system and benchmark role before acronyms or tables
- co-locate protocol, schematic, companion result, diagnostics, and interpretation when they answer the same reader question
- make every table caption state protocol, units, best-value convention, and takeaway
- keep details that support a claim, reproduction, or a diagnostic lesson; move or remove stray evidence
10) Global coherence checks during writing
Continuously verify using Grep and Read tools:
- introduction promises exactly what later sections deliver
- notation in experiments matches notation in theory
- section titles reflect actual content
- theorem numbering and equation references are stable
- section roadmaps match the real section order
- appendix references resolve cleanly
11) Progressive introduction of technical terms
Every technical term, concept, or axiom must follow this progression on first encounter:
- Plain English (caption, abstract, or first mention): Use everyday language. "facts persist until contradicted."
- Intuitive example (introduction or motivation): Ground in a concrete scenario. "Once the fridge is opened, it stays open until someone closes it."
- Design principle (method overview): State the principle with its name. "The inertia axiom — once a fluent is initiated, it persists until explicitly terminated."
- Formal mathematics (method section): Full definition with notation. "$\pred{Initiates}(e, f, t_0)$ and no terminating event in $(t_0, t] \implies \pred{HoldsAt}(f, t)$."
Rules:
- Never use a named concept (e.g., "inertia axiom", "regressive product", "Dirichlet energy") before giving the reader enough context to understand what it means at an intuitive level.
- The formal definition can come later — but the intuition must come FIRST.
- If a term appears in a figure caption or table, the caption must be self-contained enough for the reader to understand the term without reading the main text.
- Use Grep to find every occurrence of a technical term and verify the first occurrence is adequately introduced.
12) Writing style
Aim for:
- formal but motivated
- mathematically precise
- intuition immediately before or after dense equations
- minimal rhetorical fluff
- explicit transitions between sections
- first-person plural voice unless the repo style says otherwise
13) Output format when helping a user
For substantial planning, organize the working record around:
- claim graph
- notation ledger
- section contracts
- drafting plan
- proof obligations
- experiment obligations
- risks / missing assumptions
Show only what helps the user's current decision. A local correction should not produce this entire planning packet or an unsolicited deck.
14) Tool usage
- Use Glob to find all
.texfiles in the project - Use Grep to search for
\label{},\ref{},\cite{}, macro definitions, and notation patterns - Use Read to examine section contents before editing
- Use Edit for targeted changes (prefer over full rewrites)
- Use Bash to compile LaTeX and check logs:
pdflatex -interaction=nonstopmode main.tex && bibtex main && pdflatex main && pdflatex main - Use Task with
subagent_type="Explore"for broad codebase research across many files - After major restructuring, always compile and check:
grep -c "undefined" main.logandgrep "multiply" main.log
Consult:
assets/paper_blueprint.md— section contracts and structureassets/claim_proof_experiment_map.md— claim tracking templatereferences/bajaj_flow.md— theory-heavy paper flow heuristicreferences/abstract_revision_patterns.md— claim-preserving abstract revision; use when drafting or revising an abstract, or when the user asks "does this read robotic?" / "is this impressive enough?"references/researcher_persona_loop.md— researcher persona,/research-loopprotocol, and skill-routing judgement; use when the user asks to loop on a section, write and review at the same time, or decide which paper skill/tool to invoke.
Does it work?
Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.
No reviews yet
People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.
- It worked
- Partly
- It didn't
Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.
Your trail
Files you open will collect here, so you can find them again.
Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.
Now do this for your own.
Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.

