feat: add 5 new blog posts (en + zh)

- how-ai-reads-math: plain-English explainer of the recognition pipeline
- student-workflow: lecture-to-LaTeX workflow for students
- pdf-formula-issues: troubleshooting guide for PDF extraction errors
- copy-math-to-word: 3 methods for getting formulas into Word, ranked
- researcher-workflow: digitizing handwritten research notes at scale

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

content/blog/en/2026-01-15-how-ai-reads-math.md

@@ -0,0 +1,51 @@
+---
+title: "How AI Reads Math: Inside TexPixel's Recognition Engine"
+description: A plain-English explanation of how TexPixel turns a photo of a formula into clean LaTeX code
+slug: how-ai-reads-math
+date: 2026-01-15
+tags: [explainer, technology]
+---
+
+# How AI Reads Math: Inside TexPixel's Recognition Engine
+
+When you upload a photo of a handwritten integral and get back clean LaTeX in under a second, it feels like magic. It's not — but the engineering behind it is genuinely interesting. Here's a plain-English explanation of how TexPixel turns pixels into math.
+
+## Step 1: Image Preprocessing
+
+Before any recognition happens, the image is cleaned up. This step matters more than most people realize.
+
+TexPixel normalizes contrast, removes noise, deskews tilted images, and isolates the formula region from surrounding whitespace, printed text, or ruled lines. A formula photographed under harsh side-lighting — or scanned at a slight angle — is corrected before the model ever sees it.
+
+This is why image quality affects accuracy so much: preprocessing can compensate for minor flaws, but severe blur or extremely low resolution (below ~72 DPI) leaves too little information to work with.
+
+## Step 2: Symbol Detection
+
+The preprocessed image is fed into a visual encoder — a neural network that has learned, from millions of math images, what mathematical symbols look like.
+
+The key challenge here isn't recognizing individual symbols in isolation. It's recognizing them *in context*. The symbol `x` looks different when it's a variable, when it's a multiplication sign, and when it's written in different handwriting styles. The model learns to distinguish these from surrounding context: is there a dot nearby? What's the vertical position relative to a fraction bar?
+
+This contextual understanding is what separates a good math OCR system from a general-purpose character recognizer.
+
+## Step 3: Structure Parsing
+
+Recognizing symbols is only half the problem. Math is two-dimensional in a way that ordinary text is not. A fraction has a numerator above a denominator. An integral has limits at the top and bottom. A matrix arranges expressions in rows and columns.
+
+TexPixel's parser builds a structural tree from the detected symbols — understanding that this expression is a subscript of that symbol, and that expression lives inside a square root. This tree is then serialized into LaTeX, where the structural relationships are encoded as commands like `\frac{}{}`, `\sqrt{}`, `\sum_{}^{}`.
+
+## Step 4: LaTeX Generation
+
+The final step is walking the structural tree and emitting valid LaTeX. This includes choosing the right command for ambiguous cases — for example, whether a large `Σ` should be rendered as `\sum` (display math) or `\Sigma` (inline), based on context.
+
+The output is then validated to ensure it compiles without errors before being returned.
+
+## Why Handwriting Is Harder Than Print
+
+Printed math (from textbooks or PDFs) has consistent, high-contrast strokes. Handwriting varies enormously — in size, slant, stroke weight, and letter formation. Two people's handwritten `7` and `1` can look nearly identical, and two people's `β` can look completely different.
+
+TexPixel's model was trained on a large, diverse dataset of handwritten math to handle this variation. But accuracy on handwriting is always lower than on print — typically 88–95% vs. 95–99%. The [tips in our handwriting guide](/blog/handwriting-tips) can push that toward the upper end.
+
+## The Whole Pipeline in One Second
+
+Preprocessing → symbol detection → structure parsing → LaTeX generation: all of this runs in under a second. It's a well-engineered pipeline, not magic — but the speed still surprises most people the first time they try it.
+
+[Upload a formula and see it in action →](/app)