winter-super-cli 2026.5.26 → 2026.5.28

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

@@ -1,293 +0,0 @@
-# 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

@@ -1,63 +0,0 @@
-# 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

@@ -1,46 +0,0 @@
-# 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

@@ -1,66 +0,0 @@
-# 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

@@ -1,153 +0,0 @@
-# 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.