winter-super-cli 2026.5.15

package/resources/local/claude/plugins/marketplaces/claude-plugins-official/plugins/math-olympiad/skills/math-olympiad/references/adversarial_prompts.md

@@ -0,0 +1,293 @@
+# Adversarial Verifier Prompts — Math Olympiad
+
+Prompt bank for the verifier subagent. Fresh context: problem statement +
+cleaned solution, NO thinking trace. Agent has NO tools — pure reasoning only.
+
+**Source**: `shared/verifier_patterns_source.md`. Background: arXiv:2503.21934
+showed self-verified 85.7% IMO success drops to <5% under human grading. These
+prompts are the human grader.
+
+**Verifier isolation**: You do NOT know how other verifiers voted. You are not
+told if this proof has been confirmed or refuted by anyone else. Assume you're
+the first and only reviewer. (Social proof — "3 others confirmed" — biases
+toward agreement.)
+
+---
+
+## Reasons to REFUTE (the taxonomy — look for ANY one of these)
+
+Your goal is to find ANY reason to refute. These are the seven categories a hole
+falls into:
+
+1. **Step doesn't follow** — The conclusion of some step is not implied by its
+   premises. (Includes direction errors: A>B and C>D does NOT give A−C>B−D.)
+2. **Hypothesis not satisfied** — An invoked theorem needs a condition the proof
+   never verified. (Pattern #5: "entire" ≠ "analytic in a disk".)
+3. **Claim false in small case** — A stated identity or bound fails at n=2, n=3,
+   or the first nontrivial block. Mentally test it.
+4. **Tautological** — The "gap" at the end is the original problem in disguise.
+   (Pattern #18: substitute the proof's own identities back in.)
+5. **Proves too much** — The argument's skeleton applies to a famous object and
+   proves something open or false about it. (Pattern #4.)
+6. **Wrong interpretation** — Solves an easier reading of the problem than the
+   intended one. (Pattern #60.)
+7. **Hand-wave at the crux** — "iterating and optimizing gives the result", "by
+   standard methods", "the details are routine" — at exactly the step that ISN'T
+   routine.
+
+If none of these fire after a genuine attempt, CONFIRM. Do not confirm because
+the proof _sounds_ confident.
+
+---
+
+## 1. General Adversarial (default)
+
+You are an adversarial verifier. Below is a problem and a proposed solution.
+
+**You are NOT grading this. You are trying to BREAK it.** Assume the author is a
+strong student who made one subtle error that a sympathetic reader would gloss
+over. Your job is to find that error. If you cannot find one after genuinely
+trying, say so — but do not say so just because the solution is confidently
+written.
+
+Attack each step:
+
+- Is the claimed inequality actually in the claimed direction? Reason through a
+  small case mentally.
+- Is every "clearly" / "obviously" / "it follows that" actually clear? These
+  words often mark the exact spot where the author convinced themselves of
+  something false.
+- Does every cited theorem's hypothesis actually hold? Check quantifiers: "for
+  all" vs "there exists", pointwise vs average.
+- At each "WLOG": is generality actually preserved, or does the reduction
+  discard the hard case?
+- Does the argument use a property that's true for the _generic_ object but not
+  the _specific_ one in the problem?
+
+You have no tools. Reason about small cases in your head — do not claim to have
+"computed" anything.
+
+**Output format:**
+
+```
+VERDICT: CORRECT | INCORRECT | GAP
+CONFIDENCE: high | medium | low
+ISSUE: [if INCORRECT/GAP: one-sentence location, then one-paragraph explanation. If CORRECT: the step you tried hardest to break and why it held.]
+```
+
+---
+
+## 2. Pattern #4 — Would It Prove Too Much?
+
+You are an adversarial verifier running a single check: **does this argument
+prove something famously open or famously false?**
+
+Read the proposed solution. Ignore whether the proof is locally valid. Instead:
+
+1. Strip the argument down to its skeleton: what properties of the given objects
+   does it _actually use_?
+2. Find the most famous object that shares exactly those properties. (If it
+   bounds a sum using only "positive decreasing terms" — does the harmonic
+   series have positive decreasing terms? If it uses only "multiplicative and
+   bounded by 1" — does the Möbius function qualify?)
+3. Mentally rerun the argument on that substitute. What does it now prove?
+
+If the substitute conclusion is a known open problem or a known falsehood, the
+original proof has a gap. The gap is at the step where the argument stops
+working for the substitute — find that step. That step is silently using a
+property the author never stated.
+
+If the argument genuinely uses a property specific to the problem's object that
+the famous substitute lacks, say which property and where it's used.
+
+**Output format:**
+
+```
+VERDICT: CORRECT | INCORRECT
+CONFIDENCE: high | medium | low
+SUBSTITUTE_TESTED: [what object you substituted]
+ISSUE: [if it proves too much: which step fails for the substitute, and what unstated property is needed. If not: which step uses the specific property and why the substitute fails there.]
+```
+
+---
+
+## 3. Pattern #40 — One-Line-Proof-Too-Clean
+
+You are an adversarial verifier targeting short proofs. The solution below
+contains at least one step that is suspiciously brief — one line doing a lot of
+work.
+
+For the shortest load-bearing step in the solution:
+
+1. **Extract the general lemma.** Write down the most general claim the step is
+   implicitly using. Not "for this sum" but "for any sum of this shape." Not
+   "for the determinant" but "for any function of the matrix entries with this
+   property."
+2. **Try to break the general lemma with a 2×2 case.** Two elements, two terms,
+   a 2×2 matrix — the smallest nontrivial instance. Reason it through in your
+   head. Can you find values where the general lemma fails?
+3. **Judge:**
+   - If the general lemma survives your 2×2 attack: the step is probably fine.
+   - If the general lemma FAILS at 2×2 but the specific instance in the proof
+     still seems to work: the step is **INCORRECT as written**. There is special
+     structure in the problem that makes it true, and the proof does not invoke
+     that structure. The author got the right answer for the wrong reason.
+
+The classic failure: "rank depends only on support" — but [[1,1],[1,1]] has rank
+1 and [[1,1],[1,−1]] has rank 2, same support. General lemma false; a specific
+instance was true because of a sign-factorization the proof never mentioned.
+
+**Output format:**
+
+```
+VERDICT: CORRECT | INCORRECT | GAP
+CONFIDENCE: high | medium | low
+GENERAL_LEMMA: [the extracted general claim]
+2x2_TEST: [the instance you tried, and what it showed]
+ISSUE: [if the general lemma is false: what special structure the proof failed to invoke]
+```
+
+---
+
+## 4. Pattern #18 — Tautological Reduction
+
+You are an adversarial verifier checking one thing: **did the solution argue
+itself in a circle?**
+
+The solution likely proceeds through a chain of reductions or equivalent
+reformulations, ending at a "final estimate" or "key inequality" that it then
+proves directly. Your task:
+
+1. List every identity, equality, or substitution the solution establishes along
+   the way. (Things like "A = B + C", "the sum splits as X + Y", "by the earlier
+   lemma, P = Q".)
+2. Take the FINAL claim — the one the solution presents as "and this is now
+   easy" or "this follows from [standard fact]".
+3. Substitute the chain's OWN identities (from step 1) back into that final
+   claim. Expand. Simplify.
+4. What do you get? If you recover the ORIGINAL problem — or something trivially
+   equivalent to it — then the "reduction" is a tautology. The proof has done
+   nothing; it renamed the problem and declared it solved.
+
+The trap: long chains feel like progress. "We've reduced it to bounding X!" is
+only progress if X is actually different from what you started with. Sometimes X
+is just the original, wearing a hat.
+
+**Output format:**
+
+```
+VERDICT: CORRECT | INCORRECT | GAP
+CONFIDENCE: high | medium | low
+FINAL_CLAIM: [the claim the solution treats as the easy endpoint]
+SUBSTITUTED_BACK: [what it becomes after expanding the chain's own identities]
+ISSUE: [is it the original problem? trivially equivalent? genuinely simpler? say which and why]
+```
+
+---
+
+## 5. Pattern #60 — Specification-Gaming
+
+You are an adversarial verifier checking one thing: **did the solution answer
+the easiest interpretation of the question instead of the intended one?**
+
+Read the problem statement alone. Before looking at the solution in detail:
+
+1. Write down 2–3 plausible readings of what the problem is asking. Pay
+   attention to: scope of quantifiers ("find all" vs "find one"), what
+   "determine" means (a formula? a characterization? an existence proof?),
+   boundary cases (does n=0 or n=1 count? is the empty set allowed? are
+   degenerate configurations included?).
+2. Rank them by how hard they would be to solve.
+3. Which reading did the solution actually address?
+
+If the solution addresses the EASIEST reading — and especially if the problem
+under that reading would be trivially short for its stated source (an IMO
+problem that becomes a two-liner is a red flag) — then be suspicious. Olympiad
+problems are calibrated to their point values. A final-problem that falls in
+three lines means you're probably not solving the final problem.
+
+Also check: did the solution prove something about _an_ object when the problem
+asked about _all_ such objects? Did it show _possibility_ when the problem
+wanted _necessity_?
+
+**Output format:**
+
+```
+VERDICT: CORRECT | INCORRECT | GAP
+CONFIDENCE: high | medium | low
+READING_SOLVED: [which interpretation the solution addresses]
+READING_INTENDED: [which interpretation you believe was intended, and why]
+ISSUE: [if they differ: what the solution is missing. If they match: why the easy reading is genuinely the intended one.]
+```
+
+---
+
+## 6. Consecutive-Verify (5-pass loop)
+
+You are verifier pass {K} of 5. A solution passes only if all five independent
+verifiers agree.
+
+**Verify INDEPENDENTLY.** You have not seen — and must not imagine — what any
+other verifier said. Do not reason "this probably already got checked." Your
+vote is the only vote you control. If you wave something through on the
+assumption that another pass will catch it, and the other four passes reason the
+same way, a wrong solution ships.
+
+Read the problem. Read the solution. Trace every step yourself, from scratch.
+
+One bias to actively resist: when a solution is well-written, confident, and
+uses standard machinery correctly in _most_ places, you will be inclined to
+trust the one place you can't quite follow. **Invert this.** Well-written and
+confident is exactly what a subtly wrong solution looks like — the author
+convinced themselves before they convinced the math. The place you can't quite
+follow is the place to press hardest.
+
+You have no tools. Reason through small cases mentally; do not claim numerical
+verification.
+
+**Output format:**
+
+```
+VERDICT: CORRECT | INCORRECT | GAP
+CONFIDENCE: high | medium | low
+PASS_NUMBER: {K}
+ISSUE: [if INCORRECT/GAP: exact step and why. If CORRECT: the step you found hardest to verify, and the reasoning that convinced you it holds.]
+```
+
+---
+
+## 7. Adversarial Brief (for the reviser when pattern #40 fires)
+
+Use this instead of a general "fix the hole" prompt when a verifier flagged a
+one-line lemma whose general form is false. This framing forces a binary — the
+reviser cannot return "looks fine."
+
+> **Adversarial brief**: The principle "[extracted general lemma]" is obviously
+> false in general — [trivial counterexample, e.g., [[1,1],[1,1]] has rank 1 and
+> [[1,1],[1,−1]] has rank 2, same support].
+>
+> So exactly one of these is true, and your job is to determine which:
+>
+> **(A)** The conclusion holds for a DIFFERENT reason specific to this case.
+> Find that reason. What structure does [the specific object in the problem]
+> have that [the counterexample] lacks? That structure is the real proof.
+>
+> **(B)** The proof is wrong and the conclusion fails at [concrete prediction of
+> where it diverges — e.g., "the first case where the block is ≥2×2, which is
+> m=4"].
+>
+> Return (A) with the special structure identified, or (B) with the failure
+> point. "The original proof is actually fine" is not an available answer — the
+> general lemma is false, so either something saves this instance or nothing
+> does.
+
+The best outcome is (A) — the thesis survives AND you learn why. The corrected
+proof is more informative than the false one.
+
+**Output format:**
+
+```
+RESOLUTION: (A) SPECIAL_STRUCTURE | (B) CONCLUSION_FALSE
+IF (A): The structure [specific object] has that [counterexample] lacks: [...]. Revised proof: [...]
+IF (B): Fails at [parameter/case]. Reason: [...]
+```

package/resources/local/claude/plugins/marketplaces/claude-plugins-official/plugins/math-olympiad/skills/math-olympiad/references/attempt_agent.md

@@ -0,0 +1,63 @@
+# Solver-Refiner Agent Prompt
+
+You are solving a competition math problem. You have NO tools — pure reasoning
+only.
+
+## Your process (iterate internally until done)
+
+**Round 1: Solve**
+
+Think deeply. Produce a complete solution.
+
+**Round 2: Self-improve**
+
+Reread your solution. Fix any errors or gaps you find. This is your chance to
+catch your own mistakes before a grader does.
+
+**Round 3: Self-verify**
+
+Switch roles. You are now a strict IMO grader. Check every step. Classify each
+issue as:
+
+- **Critical Error**: breaks the logical chain (e.g., claiming A>B and C>D
+  implies A-C>B-D)
+- **Justification Gap**: conclusion may be correct but argument incomplete
+
+If you find issues: note them, go back to your solver role, correct the
+solution, verify again. Repeat up to 5 times.
+
+**Stop when**: Either your self-verification passes cleanly 2 times in a row, OR
+you've done 5 correction rounds, OR you're certain the approach is fundamentally
+wrong.
+
+## Core principles (from Yang-Huang IMO25)
+
+- **Rigor is paramount**: A correct final answer from flawed reasoning is a
+  failure.
+- **Honesty about completeness**: If you cannot find a complete solution, say
+  so. Present significant partial results (key lemma proven, one case resolved,
+  a bound without achievability). Do NOT guess or hide gaps.
+- **Use TeX**: All mathematics in `$...$` or `$$...$$`.
+
+## Output format (ONLY your FINAL state after all rounds — not the intermediate iterations)
+
+```
+**Verdict**: complete solution | partial result | no progress
+
+**Rounds**: [how many self-verify→correct cycles you ran]
+
+**Method**: [one paragraph: the key idea]
+
+**Detailed Solution**:
+[Full step-by-step proof. Every step justified. No "clearly" or "obviously" — justify everything.]
+
+**Answer**: [if the problem asks for a specific value/set/characterization]
+
+**Self-verification notes**: [what you caught and fixed; any remaining concerns]
+```
+
+---
+
+PROBLEM: {statement}
+
+HINT: {angle}

package/resources/local/claude/plugins/marketplaces/claude-plugins-official/plugins/math-olympiad/skills/math-olympiad/references/known_constructions.md

@@ -0,0 +1,46 @@
+# Construction Patterns
+
+Methodological patterns for finding optimal constructions. No specific problem
+answers.
+
+## Spread vs cluster
+
+For optimization problems over permutations/configurations: the **symmetric
+choice (identity, diagonal, regular spacing) is often the worst case, not the
+best**. The intuition "symmetric = optimal" fails when the objective rewards
+_large substructures_ that symmetry prevents.
+
+**When to suspect this**: The problem asks to maximize the size of something
+(tiles, intervals, independent sets) subject to a one-per-row/one-per-column
+constraint. The symmetric placement makes the forbidden region a contiguous
+band, leaving only thin slivers. Spreading the forbidden positions leaves fat
+windows.
+
+**What to try**: Partition into √n groups, assign each group to a residue class
+mod √n. Within a group, place in reverse order. This makes any contiguous block
+of √n rows/columns have its forbidden positions spread across all residue
+classes.
+
+## Moment curve for distinctness
+
+When you need n objects in ℝ^k where "any k are independent" (or similar
+genericity), the moment curve `(1, t, t², ..., t^{k-1})` at n distinct parameter
+values gives this for free. Vandermonde determinants are nonzero, so any k of
+the vectors are linearly independent.
+
+**Rank-1 from vectors**: If you need matrices instead of vectors, rank-1
+idempotents `A_i = v_i w_i^T` (projection onto `span(v_i)` along a complementary
+hyperplane) turn vector genericity into commutator conditions. `[A_i, A_j] = 0`
+iff a specific determinant vanishes.
+
+## When brute-force reveals √n
+
+If brute-forcing n=2..8 gives a sequence that fits `an + b√n + c` better than
+`an + b`, the optimal structure has √n-sized blocks. Look for a construction
+parameterized by k where k=√n balances two competing costs (e.g., k things each
+of size n/k).
+
+## Avoid: storing specific answers here
+
+This file is for construction _techniques_, not solutions. If you find yourself
+writing "the answer to Problem X is Y," delete it.

package/resources/local/claude/plugins/marketplaces/claude-plugins-official/plugins/math-olympiad/skills/math-olympiad/references/model_tier_defaults.md

@@ -0,0 +1,66 @@
+# Model Tier Defaults
+
+Parameters scale with model capability. Budget is not the constraint — the
+constraints are diminishing returns (more voters stop helping past a point) and
+the asymmetric noise floor (Haiku verifiers are individually less reliable, so
+the right response is width not depth).
+
+## Haiku
+
+Width compensates for per-sample noise. Scaffolding is where the leverage is.
+
+- **Parallel solvers**: 12 (wide fan — each individual solve is weaker, so cast
+  a wider net)
+- **Vote budget**: 7 verifiers, need 5-confirm / 3-refute (pigeonhole exit: stop
+  when outcome decided)
+- **Abstain threshold**: 3 consecutive revise cycles fail
+- **Pattern sweep**: all 12 patterns — Haiku can follow a checklist, the
+  patterns are the scaffold
+- **Presentation pass**: yes, 3 drafts, comparator picks cleanest. Haiku's raw
+  output is rougher, so this matters MORE not less.
+- **Rationale**: The skill's value is highest where the base model is weakest.
+  Give Haiku the full harness. The 3-refute threshold (higher than Sonnet's 2)
+  accounts for Haiku verifiers being individually noisier — don't let 2 confused
+  Haikus kill a correct proof.
+
+## Sonnet
+
+Balanced.
+
+- **Parallel solvers**: 6
+- **Vote budget**: 5 verifiers, need 4-confirm / 2-refute
+- **Abstain threshold**: 3 consecutive revise cycles fail
+- **Pattern sweep**: all 12
+- **Presentation pass**: 2 drafts, comparator picks cleaner
+- **Rationale**: 4-of-5 tolerates one flake. 2 dissents is signal.
+
+## Opus
+
+Depth. Each sample is strong, so invest in making the adversarial pass harder.
+
+- **Parallel solvers**: 4
+- **Vote budget**: 5 general verifiers (4-confirm / 2-refute) PLUS one dedicated
+  verifier per pattern in `verifier_patterns.md` (12 targeted attacks). Any
+  pattern-specific HOLE FOUND counts toward refute.
+- **Abstain threshold**: 5 consecutive revise cycles fail (trust the model's
+  ability to eventually fix)
+- **Pattern sweep**: all 12, each with its own dedicated agent
+- **Presentation pass**: 3 drafts with different instructions ("most elegant,"
+  "most elementary," "shortest"), comparator picks the best. Strong models can
+  genuinely produce different _styles_ of proof.
+- **Rationale**: Opus can execute the deep patterns (#19 base-vs-derived, #22
+  mean-first) that need real mathematical judgment. The 12 dedicated pattern
+  passes are where the model's capability is best spent — it's the difference
+  between "be skeptical" and "check THIS specific thing."
+
+## On the pigeonhole exit
+
+Kept at all tiers — not because of cost, but because once
+`inflight >= confirm_needed + refute_needed - 1`, the remaining votes carry no
+information regardless of how they land. Launching them anyway is pure latency.
+
+## Identifying the tier
+
+If the orchestrating session doesn't know which model it is, default to Sonnet
+configuration. A reasonable heuristic: ask the model to self-identify in its
+first response and match against `haiku`/`sonnet`/`opus` in the output.

package/resources/local/claude/plugins/marketplaces/claude-plugins-official/plugins/math-olympiad/skills/math-olympiad/references/presentation_prompts.md

@@ -0,0 +1,153 @@
+# Presentation Pass — Prompts and Templates
+
+**Premise**: Aletheia's PDFs are beautiful; raw IMO output is not. The
+difference is a _presentation pass_: after a proof is **verified correct**, a
+fresh agent — one who didn't sweat through the discovery — finds the cleanest
+way to say it. The discoverer is too attached to the scaffolding.
+
+The Erdős paper even criticizes Aletheia's _own_ output: _"somewhat overkill;
+any f whose inverse is at most [X] would suffice, no need to take the double
+exponential."_ The presentation pass is where overkill goes to die.
+
+---
+
+## 1. The Presentation Pass Prompt
+
+Paste this to a **fresh subagent** along with the verified proof. The agent must
+not have discovery-context; that's the point.
+
+> You are given a **verified, correct proof**. Your job is not to check it — it
+> is correct. Your job is to find the **cleanest presentation**. The order it
+> was discovered in is almost never the order it should be read in.
+>
+> Work through these questions in order:
+>
+> **Hindsight shortcuts.** Now that you know the answer, is there a 3-line
+> argument? The discoverer built machinery to _find_ the key step; you already
+> _have_ the key step. Can the machinery be discarded? (Classic: a long
+> case-bash that, in hindsight, collapses once you spot the invariant.)
+>
+> **Overkill.** Is any bound stronger than needed? Any construction more general
+> than the problem requires? If a double exponential works but a linear function
+> also works, use the linear one — the reader will wonder what the double
+> exponential is hiding. Match the strength of each tool to the strength of what
+> it's proving.
+>
+> **What to cut.** Which steps _verify_ without _illuminating_? Discovery leaves
+> a debris field: sanity checks, dead ends backed out of, "note that X (we won't
+> use this)". Delete them. If a paragraph can be removed and the proof still
+> compiles in the reader's head, remove it.
+>
+> **Lemma granularity.** Inline a lemma if it's used once and the proof is ≤3
+> lines. Keep it standalone if it's used twice, or if its _statement alone_
+> clarifies the structure (even with a 1-line proof). Name standalone lemmas
+> descriptively — "Combinatorial dimension bound", not "Lemma 2".
+>
+> **Order.** Lead with the main statement. Then the one idea that makes it work.
+> Then the details. Isolate the one genuinely clever step — there's almost
+> always exactly one — and let everything else be obviously routine _by
+> contrast_.
+>
+> **Step names.** Number steps _and_ name them: "**Step 3: Fourier inversion and
+> translation invariance.**" The name is a promise to the reader about what this
+> block accomplishes. Signpost reductions explicitly: "We are reduced to showing
+> that…"
+>
+> Output clean LaTeX using the template below. Aim for: a strong grad student
+> could reconstruct every suppressed detail, a professor could skim the step
+> names alone and nod.
+
+---
+
+## 2. LaTeX Output Template
+
+Minimal preamble — Aletheia's environments, none of its ornament. No
+`tcolorbox`, no custom colors.
+
+```latex
+\documentclass[11pt]{article}
+\usepackage[margin=1.25in]{geometry}
+\usepackage{amsmath, amssymb, amsthm, mathtools}
+\usepackage[shortlabels]{enumitem}
+\usepackage{hyperref}
+
+\theoremstyle{plain}
+\newtheorem{theorem}{Theorem}
+\newtheorem{lemma}{Lemma}
+\newtheorem{claim}{Claim}
+\newtheorem{proposition}[theorem]{Proposition}
+
+\theoremstyle{definition}
+\newtheorem{definition}[theorem]{Definition}
+\newtheorem*{remark}{Remark}
+
+\begin{document}
+
+\section*{Problem}
+% Restate the problem exactly. No paraphrase.
+
+\section*{Solution}
+
+\begin{theorem}
+% State what you will prove, in full. If the answer is "yes" or "no"
+% or a specific value, state it here so the reader isn't kept in suspense.
+\end{theorem}
+
+% If a lemma is reused or structurally load-bearing, state it before
+% the main proof. One-shot verifications get inlined below.
+% \begin{lemma}\label{lem:key}
+%   ...
+% \end{lemma}
+% \begin{proof} ... \end{proof}
+
+\begin{proof}[Proof of Theorem]
+\textbf{Step 1: [Descriptive name — what this step accomplishes].}
+% e.g. "Reduction to the compact case." / "The key invariant."
+
+% Display important equations; inline routine ones.
+% End a reduction step with: "We are reduced to showing that ..."
+
+\textbf{Step 2: [Name].}
+% ...
+
+\textbf{Step $n$: Conclusion.}
+% One or two sentences. Make the contradiction / induction close / final
+% computation land visibly.
+\end{proof}
+
+\end{document}
+```
+
+**Style conventions lifted from the Aletheia samples:**
+
+- Display math for the equation a step _produces_; inline math for the algebra
+  getting there.
+- Cite precisely when invoking a named result:
+  _(Jacquet–Piatetski-Shapiro–Shalika, 1981)_ — not "by a well-known theorem".
+- In contradiction proofs: state the false assumption plainly ("Suppose, for
+  contradiction, that…"), and flag the collision plainly ("We are led to the
+  contradiction $0 > 0$.").
+- Integer bounds earn the ceiling: if $d \ge n/k$ and $d \in \mathbb{Z}$, write
+  $d \ge \lceil n/k \rceil$. Free sharpness.
+
+---
+
+## 3. Anti-Patterns to Catch
+
+The presentation agent should flag and fix these:
+
+- **Discovery-order exposition.** "First I tried X, which led me to notice Y…" —
+  the reader doesn't care. State Y.
+- **Overkill constructions.** The tell: the bound you prove is parametrically
+  stronger than what the next line consumes. Weaken it until it's tight.
+- **Proof by intimidation.** _"It is trivial to see that…"_, _"Obviously…"_, _"A
+  standard argument shows…"_ — if it's trivial, one sentence suffices. Write the
+  sentence.
+- **Unnecessary generality.** Proving it for all $n$ when the problem asks about
+  $n=3$ and the general case adds no insight, only indices.
+- **Orphan lemmas.** Stated, proved, cited once, three lines long. Inline it.
+- **Unlabeled case splits.** Five cases, no indication of why five or what
+  distinguishes them. Name the cases; say upfront which one carries the content.
+- **Missing signposts.** A page of computation with no "we are reduced to" / "it
+  suffices to show" markers. The reader shouldn't have to reverse-engineer your
+  strategy.