Math Lens

Always produce a self-contained HTML file saved as math-lens-output.html.

Structure

[Context Banner]           ← 1-2 sentences: what this section is doing overall
[Formula Selector]         ← clickable pills for each formula found
[Formula Detail Panel]     ← tabbed view: Intuition | Code | Symbols
[Engineering Footnote]     ← where this appears in real systems/frameworks

Tab 1 — Intuition

• Lead with what the formula is doing, not what it means symbolically
• Use a numbered step-by-step breakdown (3-5 steps max)
• End with an analogy grounded in the domain (not generic)
• Max 120 words total

Tab 2 — Code

• Translate the formula into Python/NumPy (prefer numpy over math library)
• Add inline comments explaining each line's role
• If the formula has approximations used in practice (e.g., log-sum-exp trick), show the engineering version, not just the textbook version
• Include a small concrete example with real numbers

Tab 3 — Symbols

• Table format: Symbol | What it represents | Intuitive type
• "Intuitive type" means: scalar / vector / matrix / function / set / index
• Highlight symbols that look the same but mean different things in different formulas

Web Search Usage

Use web search when:

• The formula belongs to a named algorithm (e.g., "Viterbi", "Softmax", "Adam optimizer") → search for its PyTorch/NumPy implementation
• You need to confirm which framework uses this formula in production
• The paper references a specific model architecture

Search queries to use:

• "{formula name}" pytorch implementation site:github.com
• "{formula name}" intuitive explanation site:distill.pub OR towardsdatascience.com
• "{algorithm name}" when to use practical engineering

Add an Engineering Context section below the tabs with:

• Which real frameworks implement this (PyTorch, Kaldi, scikit-learn, etc.)
• One concrete link to a reference implementation
• Common pitfalls engineers hit when implementing this

Handling Formula Chains

When multiple formulas form a derivation (e.g., A → B → C via simplification):

1. Open with a chain overview: "These 4 formulas show one idea getting progressively simplified for engineering use"
2. Show a visual flow: Formula 2.1 → drops P(O) → Formula 2.2 → adds pronunciation layer → Formula 2.3 → log trick → Formula 2.4
3. For each formula, explain what changed from the previous one and why
4. The final formula is usually the one engineers actually implement — emphasize it

Output Quality Rules

• Never explain what a symbol "is" without explaining what it does Bad: "W is the word sequence" Good: "W is the candidate text the ASR system is testing — think of it as one hypothesis in a beam search"

• Always show numbers If a formula takes inputs, compute a toy example. Abstract explanations don't stick.

• Code must run Do not write pseudocode unless the formula is genuinely non-computable. Prefer executable numpy/python.

• Respect the user's context If the screenshot is from an ASR paper, your analogies should use audio/speech examples. If it's from a vision paper, use image examples. Read the domain from the image before writing a single word of explanation.

HTML Output Spec

• Single self-contained file, no external dependencies except MathJax CDN for formula rendering
• Load MathJax from: https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js
• Use tab switching via vanilla JS (no frameworks)
• Mobile-friendly: formula pills wrap on small screens
• Color scheme: clean white background, monospace for code blocks, clear visual hierarchy
• Include the original formula rendered via MathJax in each detail panel header

Example Invocation

User: [attaches screenshot of ASR paper with 4 Bayes formulas]
       "Can you explain this?"

Skill: Produces math-lens-output.html with:
       - Context: "Traditional ASR decomposes P(W|O) into three independent models..."
       - 4 formula pills: [Formula 2.1] [Formula 2.2] [Formula 2.3] [Formula 2.4]
       - Each pill reveals Intuition/Code/Symbols tabs
       - Engineering footnote: "This is the core of Kaldi's decoding graph..."

Do Not

• Do not explain formulas as if teaching a math class
• Do not use phrases like "it can be shown that" or "by definition"
• Do not skip the code tab — it is the most important tab for engineers
• Do not produce multiple HTML files — one file contains everything
• Do not explain every symbol if the formula has obvious ones (e.g., don't explain what "log" means)