Universal Textual Teaching for LLMs

Primer: Olympiad Problem-Solving Patterns

0 Output discipline

• End with a finite checkable proof/boxed answer; prefer compact algebra, counting, or graph arguments.
• Verify definitions, boundary cases, and small examples before trusting analogies or known results.

1 Geometry

• Circle tangency via coordinates: normalize; circle through points $x^2+y^2+ax+by+c=0$; prove common point and proportional gradients.
• Billiards by unfolding: reflect polygon, not ray; path becomes straight segment in tiling; use gcd/color conditions for vertex hits.
• Distinguish metric vs combinatorial definitions; use explicit polar/nonregular counterexamples.
• Tetrahedron altitude from six edges: build base $B'C'D'$; build rotated face points $A_B$ opposite side of $C'D'$ with $A_BC'=AC, A_BD'=AD$, and $A_C$ opposite side of $B'D'$ with $A_CB'=AB, A_CD'=AD$. Perpendiculars from $A_B$ to line $C'D'$ and $A_C$ to line $B'D'$ meet at the true foot $X'$. Altitude $=\sqrt{|A_BY'|^2-|X'Y'|^2}$, constructible by Pythagorean difference. Use full supporting lines, not segments. Foot from $A$ to line $BC$ has signed $BP=(AB^2+BC^2-AC^2)/(2BC)$; $BP<0$ or $BP>BC$ means foot outside segment. Transfer signed positions; unsigned distances fail in obtuse cases.

2 Number theory and polynomial values

2.1 Vieta jumping/descent

For $(a+b)(a+b+1)/(ab)=N$: fix $N$, rewrite as quadratic, Vieta gives positive integer other root; descend to equal pair; verify integrality/positivity.

2.2 Lyndon words and fractional parts

Suffix/prefix lex conditions become Lyndon words; count length $L$ over $q$ by $\frac1L\sum_{d\mid L}\mu(d)q^{L/d}$.

2.3 Reduced denominators / averaging

For $S_n=A_n/n!$, denominator $n!/\gcd(A_n,n!)$; lifts $A_{r+p^k}\equiv A_r-p^k\pmod{p^{k+1}}$; existence via averaging and Stirling.

2.4 Sum-of-$k$-others and omitted elements

If each element is a sum of $k$ others in a set of $k+m$, count omitted elements; compare largest/smallest omitted sums. Don't use sign-count bounds: largest need not be positive sum. For zero-sum symmetric sets solve $a+b+c=-2x$.

2.5 Digit sums and carries

$\sigma(10m+i)=\sigma(m)+i$; safe block iff $\sigma(m)\equiv1\pmod{11}$; trailing-9s give $\sigma(m+1)-\sigma(m)=1-9t$. Maximal safe intervals shape $9+10+10+9$.

2.6 Integer-valued polynomials and $P(i)$

• Integer-valued iff $P(x)=\sum c_k\binom{x}{k}$, $c_k\in\mathbb Z$.
• At $x=i$, analyze $v_\pi(\binom{i}{k})=v_\pi(N_k/k!)$. For $p\equiv1\pmod4$, $p=\pi\bar\pi$ in $\mathbb Z[i]$; Hensel gives $s$ with $\pi^e\mid i-s$, so among $i,\dots,i-k+1$ at least $\lfloor k/p^e\rfloor$ are divisible by $\pi^e$; hence no $p\equiv1\pmod4$ appears in denominators.
• $p=2$ or $p\equiv3\pmod4$ attainable: $1/2=6\binom{x}{4}+3$; $1/p=(p-1)!\binom{x}{p}$.
• Answer: $a+bi$, $a,b\in\mathbb Q$, with $\nu_p(a),\nu_p(b)\ge0$ for every $p\equiv1\pmod4$. Not all $\mathbb Q(i)$: $1/5$ excluded.

2.7 Prime-divisor constraints $\omega(n)>K$

• Strict $>K$ means minimal $\omega(n)=K+1$; constants $c$ need $c>0$, $\omega(c)\le K+1$. Boundary $\omega(c)=K+2$ with $\omega(n)=K+1$.
• Monomials $x^m$ work.
• Nonconstant nonmonomials fail. If $P(0)\ne0$, Schur gives $K+2$ primes $q_i$ with nonzero roots $a_i\bmod q_i$; CRT+Dirichlet builds $n$ with exactly $K+1$ prime factors and $n\equiv a_i\bmod q_i$; then $q_i\mid P(n)$, $q_i\nmid n$, so $\omega(P(n))\ge K+2$ or $P(n)\le0$. If $P(0)=0$, factor $x^mQ(x)$, $Q(0)\ne0$, apply to $Q$; handle constant factor $c>1$.

3 Scheduling and exact-degree constructions

• Tournament stays: interval per player; pairwise intersection + Helly gives common day; one match at central day; total cost baseline $2M$ plus idle player-days; balance distinct players before/after.
• Touch/degree: for $n$ objects each touching exactly 3 others, handshake gives $3n$ even, so $n$ even; do not infer divisibility by 4. For large even $n$, cycle base (outside squares on $4m$-gon plus reflected pairs gives $6m$) and insert four-square gadgets at cuts to add 8 or 16, covering residues mod 6; verify no unintended intersections.

4 Hamiltonian paths on grids

• Numbering an $n\times n$ grid is a Hamiltonian path; diagonal projection gives a $\pm1$-walk, main diagonal visits same parity. Bound first/last visits using side color counts; construct explicitly.

5 Permutation reachability via swap graphs

• Allowed swaps = graph edges; connected graph iff every permutation reachable. Prove connectivity by explicit spanning path; disprove by separated component.

6 Local block constraints and two-stage counting

• Count distinguished positions first, then assign remaining; encode as $0,\pm1$. For $2\times2$ zero-sum blocks, general solution $a_{ij}=(-1)^{i+j}(r_i+c_j)$; propagate sign choices across overlaps.

7 Hyperplane-generic finite sets

• Minimal $k$-generic sets: lower via concurrent lines with $k$ points; upper via private-point subcover and affine linear functions; incidence/basis gives $|M|\le kn$ for $k,n>1$.

8 Partition minima and smoothing

• Define $S(N)=\min_{n_1+\cdots+n_m=N}\sum f(n_i)$ for nonincreasing $f$. Balanced partition is only an upper bound: $S(N)\le r f(q+1)+(m-r)f(q)$, $N=mq+r$, $0\le r<m$. Summing one fixed partition family overcounts because $S$ is the minimum over all partitions. Count all zero parts: for $m=20$, $N=0,\dots,19$, coefficient of $f(0)$ is $20+\cdots+1=210$, not 20.
• Smoothing extremal: if $\sum f(i)=A=\binom{a+1}{2}$, then $\sum_{N\ge0}S(N)\le \sum_{N=0}^{ma}(ma-N)=ma(ma+1)/2$. Equality at $f(i)=\max(a-i,0)$, $g(N)=\max(ma-N,0)$. Verify: $f(n_i)\ge a-n_i$, so sum $\ge ma-N$, and sum $\ge0$.

9 Fair bounded selection with biased coins

• Do not assume arbitrary outcome probabilities can be partitioned into $n$ equal groups. For $n=3$, $p=1/3$, $L=3$, weights $8,4,4,4,2,2,2,1$ cannot split into three sums 9 (8 must pair with 1; remaining even weights cannot sum 9).
• Verified construction: choose $p_1=1/n$, $p_2=1/2$; take $c$ with $N=2^c\ge n(n-1)$, announce $L=c+1$. Toss coin1 once, coin2 $c$ times. In units $1/(nN)$, there are $N$ $T$-outcomes of weight $n-1$ and $N$ $H$-outcomes of weight 1; each person needs total weight $N$. Write $N=qn+r$, $0\le r<n$; set $a_i=q+1$ for $r$ people, $a_i=q$ otherwise; $b_i=N-a_i(n-1)$. Feasibility $a_i(n-1)\le N$ follows from $N\ge n(n-1)$. Assign $a_i$ $T$-strings and $b_i$ $H$-strings to person $i$; probability $a_i(n-1)/(nN)+b_i/(nN)=1/n$. Explicitly verify the partition before announcing.

10 Validation checklist

• Integer-valued polynomials: binomial basis; check split primes $p\equiv1\pmod4$ separately.
• $\omega(n)>K$: convert to $K+1$; constants separately; Schur+CRT/Dirichlet to force prime divisors.
• Touch/degree: handshake parity; avoid extra divisibility; test constructions for unintended coincidences.
• Scheduling/grid/digit/local-counting: include idle days; diagonal parity and explicit attainment; carry blocks; propagate overlap consistency.
• Vieta jumping: verify positive integral new root. Circle tangency: check membership and gradients. Counting formulas: check divisors/Möbius signs.
• Tetrahedron altitude: use supporting lines and signed foot distances; test obtuse cases ($BP<0$ or $BP>BC$); verify intersection is true projection.
• Partition minima: balanced partition is upper bound not exact; count zero coefficients; verify extremal construction.
• Fair selection: verify explicit equiprobable partition for announced bound; test small $n$/parity counterexamples.

PRIMER: Writing Custom CUDA Operators for PyTorch Models

Core Requirements

• Replace operators with a custom CUDA implementation, typically inside a torch.autograd.Function or as a direct extension function.
• No try/except or fallback logic — let assertions crash.
• Output format is critical: the entire answer must be raw Python source, starting with the first character and continuing until the end. If the instruction says “output only the code,” the response must be solely the code block—no introductory or trailing text and no Markdown fences.
• All methods must be fully implemented, with no placeholders.

Token Budget & Code-First Strategy

• Code output must come immediately. Spending the budget on reasoning before the code can lead to truncation, leaving no answer at all.
• Prefer a minimal, correct kernel, such as one thread per output element or a serial scan, to remain within the token limit.
• For inference-only tasks, skip backward computation by raising NotImplementedError.
• Target roughly 60–80 lines of model code; simplify kernels that grow substantially larger.

Symbol Visibility Before Binding (Critical)

Every function referenced by m.def must be known at the point of registration. The extension binding code is a plain C++ translation unit and does not permit linking later to unresolved symbols. Two safe patterns are:

1. Monolithic source (recommended): define all functions before the PYBIND11_MODULE block inside a single CUDA source string and leave cpp_sources=[].
2. Multi-file: declare the wrapper function in a header included by the binding file. Its definition in a separate .cu file must exactly match the declaration.

The host function signature must be compatible with torch::wrap_pybind_function, conceptually a std::function accepting the specified argument types and returning a torch::Tensor. Using &my_func directly is simpler and preferred.

Monolithic Template (Safe)

cuda_src = r'''
#include <torch/extension.h>
__global__ void my_kernel(...) { ... }
void my_op(torch::Tensor x, torch::Tensor y) { ... /* launch kernel */ }
PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {
  m.def("my_op", &my_op, "doc");
}
'''
ext = load_inline(name="my_ext", cpp_sources=[],
                  cuda_sources=[cuda_src], verbose=False)

General Kernel Design Patterns

• One thread per output for convolution, pooling, and similar operations: launch one thread per output element, loop over kernel and channel dimensions, and use __ldg for read-only data.
• Scan-type operations such as cumulative sums: default to one thread per independent slice, looping sequentially over the scan dimension. This is simple, token-efficient, and reliable.
• Reverse cumulative sums: loop from right to left rather than composing flip, cumulative sum, and another flip.
• Multidimensional indexing: parenthesize expressions aggressively to avoid compilation failures caused by missing parentheses.

Implementing Scan Operations

• Treat the tensor as (num_vectors, L), moving the target dimension to the final position when necessary.
• Launch num_vectors threads, each performing a serial inclusive scan.
• For a reverse cumulative sum, iterate from right to left.
• Let the host wrapper move the target dimension to the end, launch on a two-dimensional view, and permute the result back.

Extension Building with load_inline

• Exactly one PYBIND11_MODULE must appear, with TORCH_EXTENSION_NAME as its first argument.
• The name supplied to load_inline must match the module name represented by the macro.
• Use extra_cflags=["-O3"] and extra_cuda_cflags=["-O3"].
• Compile once and cache the module at the class level to avoid recompilation for every instance.

Lazy Compilation (Class-Level Caching)

class ModelNew(nn.Module):
    _ext = None
    def __init__(self, dim):
        if ModelNew._ext is None:
            ModelNew._ext = load_inline(
                name="op",
                cpp_sources=[],
                cuda_sources=[cuda_src],
                verbose=False)
        self.ext = ModelNew._ext

Testing Builds Locally

Verify that a small extension compiles and executes before integrating it:

ext = load_inline(name="test", cpp_sources=[],
                  cuda_sources=[cuda_src], verbose=True)
x = torch.randn(1, 1, 8, 8, 8).cuda()
ext.my_op(x, ...)

Common Failure Modes

Verification Checklist

• Output is pure Python source, without fences or commentary when these are forbidden.
• Code is emitted immediately without prolonged reasoning.
• Exactly one PYBIND11_MODULE is present, and every referenced host function is visible beforehand.
• Host functions accept PyTorch-compatible types rather than raw pointers.
• No fallback logic appears in the optimized implementation.
• Tensor contiguity is checked or handled.
• Reverse scans traverse in reverse rather than composing flips.
• Multidimensional index expressions are balanced and tested.
• The extension is tested on a small tensor before a full benchmark run.

PRIMER: Multiple-Choice Geometry from a Figure

0. Non-negotiable output rule

One letter is the deliverable. Write "Answer: X" first (or end with the bare letter on its own line), then 2–6 lines of justification. Nearly every observed failure was identical: no final output — budget burned re-reading the figure, cataloguing every labeled value, or debating which vertex owns a number. Partial reasoning scores zero; a best guess always beats silence.

Budget policy: 2–4 reasoning steps, at most one or two figure interpretations, then stop.

• Value matches an option $\rightarrow$ commit; stop verifying.
• Matches nothing $\rightarrow$ say so in one sentence, switch the assignment once, else pick the nearest listed value.
• Never solve for every lettered unknown; stop the instant the target is pinned.
• "Cannot be determined" only after a determinate chain visibly breaks — never as a hedge.

1. Read the figure, then isolate one unknown

• Attach each number to the vertex/side/bracket its mark touches; name it ("$\angle MLJ=30^\circ$"). An arrow from a value just labels the adjacent lettered angle ($r^\circ\leftarrow90$ means $r=90$).
• Decide what each length denotes: radius vs diameter, whole bracket vs sub-segment, side vs apothem, slant vs height. Label-swapping is the #1 distractor generator. An arrow drawn inside a small circle from its center is that circle's radius.
• List only the structural facts you need: which point-triples are collinear, which segments are parallel/tangent.
• Chain, don't systematize: anchor on the triangle/relation with two knowns, propagate, stop.
• Prune decoys explicitly; extra labels often serve other sub-questions.
• Not-to-scale figures: test candidate readings against options; keep the clean one.

2. Angle propagation toolkit

Two tools carry most crossing-line figures: vertical angles at the intersection and $180^\circ$ sums (triangle, straight angle). Template: triangle with two given angles $\rightarrow$ third angle $\rightarrow$ vertical angle across $\rightarrow$ next triangle $\rightarrow$ straight-angle subtraction $\rightarrow$ target.

Parallel lines: arrowheads declare the parallel pair; find the transversal joining target to given. Corresponding/alternate interior $\Rightarrow$ equal; co-interior or linear pair $\Rightarrow$ supplementary. Misreading same-side as alternate gives the $180-\theta$ distractor. Extended ray $\Rightarrow$ linear pair. In a parallelogram a diagonal is a transversal for both side pairs; pair the correct halves. Quadrilateral interior sum $360^\circ$.

3. Congruent/joined figures

Congruent polygons glued along a shared side: corresponding angles transfer; the angle at a seam vertex is usually the sum of one angle from each. Validate with polygon angle sums.

4. Similar triangles (parallels, shadows, mirrors)

$AB\parallel CD$ with apex $P$ $\Rightarrow\triangle PAB\sim\triangle PCD$; $h(P\rightarrow AB)=(AB/CD)\cdot h(P\rightarrow CD)$. Distance between parallels $=h_{\mathrm{total}}-h_{\mathrm{sub}}$ (must be $<$ total). Mirror/shadow: $h_{\mathrm{far}}/h_{\mathrm{near}} =d_{\mathrm{far}}/d_{\mathrm{near}}$.

5. Circle toolkit

• Find diameters first: collinear labeled points through the center $\Rightarrow$ adjacent central angles are a linear pair; all central angles sum 360.
• Arc notation: two letters = minor arc = central angle; three letters = arc through the middle letter, usually major $\Rightarrow360-\mathrm{minor}$ ($>180^\circ$).
• Inscribed = $\frac12$ arc; central = $2\times$inscribed; cyclic quad opposite angles supplementary; chord = $2R\sin A$.
• Tangent from external $P$: tangent $\perp$ radius; $AP=OP\cdot\sin\angle AOP$, $r=OP\cdot\cos\angle AOP$; check $r<OP$.
• Equidistant chords $\Rightarrow$ congruent chords $\Rightarrow$ congruent arcs $\Rightarrow$ equal inscribed angles.
• Internally tangent circles: centers and contact point are collinear. Two equal circles of radius $r$ internally tangent to a big circle at opposite ends of a diameter and tangent to each other $\Rightarrow R=2r$.
• Perimeter of a curvilinear region = sum of arc lengths, each $(\theta/360)\cdot2\pi\rho$ with its own radius. Half of a circle of radius $\rho$ contributes $\pi\rho$. Typical shaded lune: $\pi R+\pi r+\pi r$. Rectangle on a semicircle diameter: $h=\sqrt{R^2-(w/2)^2}$.

6. Area by symmetry and cancellation

Shaded = whole $-$ unshaded; hunt equal-area pieces first. Common apex $\Rightarrow$ compare triangles by base alone: apex at a rectangle's center gives every top/bottom triangle height $H/2$, area $bH/4$, so group bases until they sum to a full side (top set = bottom set = $\frac14$ of area; sides = $\frac12$). If a shaded base and its mirror unshaded base are equal, shaded bases total one full width $\Rightarrow\frac14$ of the rectangle. Verify all region fractions sum to 1. Assume convenient dimensions ($4\times2$) or coordinates. Quarter disc radius $r$ and semicircle on its chord both have area $\pi r^2/4$ $\Rightarrow$ shaded = $\frac12r^2$; $\pi$-free answers signal cancellation.

7. Cone/net toolkit

$(\theta/360)\cdot2\pi R=2\pi r$; $\theta=90^\circ\Rightarrow R=4r$. Lateral surface = $\pi rl$; $l^2=h^2+r^2$. $AE=AF$, $DE=DF\Rightarrow$ axis $\perp$ base.

8. One-line validation, then emit

Supplements sum 180; polygon sums close; drawn obtuse $\Rightarrow>90^\circ$; chord $\leq$ diameter; $r<$ distance to external point; fractions sum to 1; magnitude plausible against options. Name the licensing relation per step. Then emit the letter.