Operating procedure

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) Draft in this order

Default order:

1. problem statement and assumptions
2. notation / preliminaries
3. method
4. theorem statements and proof plan
5. experiments design
6. introduction
7. abstract
8. appendix roadmap
9. conclusion

Reason: The introduction should summarize a structure that already exists.

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:

1. state the task in the variables the paper will actually use later
2. define the deployment object or system specification that explains what varies at transfer
3. define the predictor or operator chain explicitly
4. state the empirical objective and hard architectural constraints
5. build the central operator in the order its mathematics depends on
6. return to the deployed pipeline and give a tutorial-grade algorithm
7. 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

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.

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:

1. Plain English (caption, abstract, or first mention): Use everyday language. "facts persist until contradicted."
2. Intuitive example (introduction or motivation): Ground in a concrete scenario. "Once the fridge is opened, it stays open until someone closes it."
3. Design principle (method overview): State the principle with its name. "The inertia axiom — once a fluent is initiated, it persists until explicitly terminated."
4. 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

Unless the user asks otherwise, structure your assistance as:

1. claim graph
2. notation ledger
3. section contracts
4. drafting plan
5. proof obligations
6. experiment obligations
7. risks / missing assumptions

14) Tool usage

• Use Glob to find all .tex files 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.log and grep "multiply" main.log

Consult:

• assets/paper_blueprint.md — section contracts and structure
• assets/claim_proof_experiment_map.md — claim tracking template
• references/bajaj_flow.md — theory-heavy paper flow heuristic