math-skill 2.0.1 → 3.0.0

package/README.en-US.md

@@ -2,58 +2,105 @@
   <a href="README.md">中文</a> | <a href="README.en-US.md">English</a>
 </p>
 
-# ⚔️ Math Skill — Math Research Activator
+# ⚔️ Math Skill — A Mathematical Research Operating System for AI Architecture Design
 
-> **Activating modern mathematics (algebraic geometry / differential geometry / Lie theory / category theory / matrix analysis / optimization) into algorithm × GPU co-design — beautiful in math, friendly to GPUs.**
+> **The thinking system does not hand out theorems. The knowledge system does not improvise inspiration. The design layer does not fake profundity.**
 
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
 [![npm version](https://img.shields.io/npm/v/math-skill.svg)](https://www.npmjs.com/package/math-skill)
+[![npm downloads](https://img.shields.io/npm/dt/math-skill.svg)](https://www.npmjs.com/package/math-skill)
 
 ---
 
-## Philosophy
+> **If this project inspires you, please consider leaving a Star⭐.** Every Star is a resonance with the beauty of mathematics — and the fuel that keeps this project alive. Welcome, every fellow traveler who loves math and sails its vast ocean.
 
-The mathematical foundation of this AI revolution is **20th-century mathematics stepping onto the commercial computing stage for the first time** — category theory, algebraic topology, algebraic geometry. Most mainstream algorithms today still rest on the 1800–1900s calculus / linear algebra. Activating modern mathematics into algorithm design is the most important thing in the algorithm exploration phase.
+---
 
-This skill packages sixteen core mathematical ideas into callable thinking frameworks, and **steps in automatically** when the workspace contains ML / model code, CUDA / kernels, or algorithm research notes: diagnose the problem → map modern mathematical structures → route thinking weapons → GPU feasibility screening. Every deliverable must pass a **double acceptance gate**:
+## Inspiration
 
-1. **Beautiful in math** — self-consistent, differentiable (or relaxable to differentiable), with correctness guarantees.
-2. **Friendly to GPU** — passes the eight-dimensional gate in `references/gpu-friendly-math.md`.
+The story of Sophus Lie forging a "dragon-slaying blade" tells us this: the Lie group–Lie algebra machinery invented to solve differential equations ended up becoming the lingua franca for describing symmetry and robot state estimation — the value of a mathematical tool far outlives its original intent, which is exactly the prototype of "cross-domain activation." See [`references/inspiration.md`](references/inspiration.md).
 
-> "The model already has enough math inside; what's missing is a single cross-domain activation. Humans pick direction; the agent searches, enumerates, and verifies."
+> The most fascinating thing about mathematics: a tool invented for one problem reveals unforeseen power in an entirely different domain.
 
 ---
 
-## What v2.0.1 Does
+## Philosophy
+
+When you face an AI research problem, this system helps you answer four questions:
 
-- **Auto-trigger entry**: `math-research-activator` only intervenes when both environment signals (workspace contains architecture core code / CUDA kernel / research notes) AND task signals (designing new architectures / operators, analyzing theoretical properties, transferring mathematical structures) are hit. Pure engineering tasks (debugging, code review, refactoring, hyperparameter tuning) do NOT trigger.
-- **Modern math activation layer**: `references/books/*.md` × 7 (algebraic geometry, differential geometry, Lie theory, abstract algebra, matrix analysis, optimization, manifolds) serve as low-token activation indices, loaded by problem type — they do not replace the full books.
-- **GPU 8-D cross-cut**: all 15 thinking weapons are explicitly mapped to the formal eight dimensions of `references/gpu-friendly-math.md`: tensorization / GEMM-mappability / complexity / memory & KV-Cache / low-precision stability / parallelism & communication / sparse structure / operator fusion.
-- **Single research path**: oriented toward research, algorithms, operators, and training/inference infra; the life-advice mode has been dropped.
-- **Progressive disclosure**: resident layer (activator + description) → methodology layer (on demand) → book layer (on demand), keeping irrelevant context out of the prompt.
+1. **What mathematical perspective should I use?** → Thinking Lenses
+2. **What specific math do I need?** → Knowledge Base
+3. **How do I turn math into model design?** → Design Translation
+4. **Is it mathematically sound and engineering-feasible?** → Critic
+
+```
+Problem
+ ↓
+Thinking Lenses: What perspective fits this problem?
+ ↓
+Math Knowledge: What specific tools does this perspective need?
+ ↓
+Design Translation: How do these tools become model structures / losses / operators?
+ ↓
+Critic: Mathematically sound? Engineering-feasible?
+```
 
 ---
 
-## Sixteen Thinking Weapons
-
-| # | Thinking Weapon | Core Idea | Algorithm / GPU Application |
-|---|----------------|-----------|----------------------------|
-| 0 | 🧭 [Math Research Activator](skills/math-research-activator/SKILL.md) | Auto-trigger entry: diagnose → map → route → GPU filter, with a double acceptance gate | Intervenes only when both environment AND task signals hit; pure engineering tasks are excluded |
-| 1 | 📐 [Axiomatization](skills/axiomatization/SKILL.md) | Build rigorous logic from the fewest assumptions | Review algorithm assumptions; pin down axioms and invariants for structures |
-| 2 | 🧩 [Abstraction](skills/abstraction/SKILL.md) | Grasp the essence, ignore non-essential detail | Extract transferable structures; discover cross-domain commonalities |
-| 3 | 🧠 [Logic Deduction](skills/logic-deduction/SKILL.md) | Rigorously derive new truths from existing truths | Formally verify algorithm correctness; loop invariants |
-| 4 | 🌉 [Modeling](skills/modeling/SKILL.md) | Real problem → math problem → explain reality | Build computable models; parameterized selection |
-| 5 | ⚖️ [Optimization](skills/optimization/SKILL.md) | Find the optimum under constraints | Optimizer selection; second-order GPU feasibility; duality |
-| 6 | 🎲 [Probability & Statistics](skills/probability-statistics/SKILL.md) | Quantify uncertainty; extract patterns from data | Randomized algorithms, sampling, quantization, training dynamics |
-| 7 | 🔄 [Transformation](skills/transformation/SKILL.md) | Complex problem → equivalent simpler problem | Conv → GEMM, spectral transforms, KV frequency-domain compression |
-| 8 | ⚛️ [Symmetry & Invariance](skills/symmetry-invariance/SKILL.md) | Properties preserved under transformations | Equivariant networks (SO(3)/SE(3)), tropical semiring routing |
-| 9 | 📈 [Induction & Analogy](skills/induction-analogy/SKILL.md) | From special to general, known to unknown | Cross-domain structure transfer; inductive bias design |
-| 10 | 🖥️ [Algorithmic Thinking](skills/algorithmic-thinking/SKILL.md) | Reduce to finite steps; evaluate cost and feasibility | Sub-quadratic complexity, parallelism, operator fusion |
-| 11 | 📡 [Information Theory](skills/information-theory/SKILL.md) | Information is the reduction of uncertainty | Compression, pruning, quantization, KV compression, routing |
-| 12 | 🎯 [Game Theory](skills/game-theory/SKILL.md) | Optimal strategy depends on others' choices | Multi-agent, adversarial training, routing games |
-| 13 | 🔗 [Causal Inference](skills/causal-inference/SKILL.md) | Correlation ≠ causation, but causation can be formalized | Interpretability, OOD generalization, DGP modeling |
-| 14 | 🌀 [Topological Thinking](skills/topological-thinking/SKILL.md) | Properties preserved under continuous deformation | Čech cohomology regularization, sheaf attention, TDA |
-| 15 | 🧮 [Discrete & Combinatorial Thinking](skills/discrete-combinatorial/SKILL.md) | Counting, enumeration, laws of finite objects | Sparse structure, routing, finite-field / semiring algorithms |
+## Three-Layer Orthogonal Architecture
+
+| Layer | Role | Directory | Files |
+|-------|------|-----------|-------|
+| **Thinking Lenses** | Diagnose problem structure, recommend math perspectives | `lenses/*.md` | 15 |
+| **Math Knowledge** | Provide concrete math tools (definitions/theorems/formulas) | `knowledge-base/*/*.md` | 31 |
+| **Design Translation** | Bridge math to AI modules/losses/operators | `design-patterns/*/*.md` | 22 |
+
+Supporting layers:
+- `references/books/*.md`: 7 book distillations for deep context
+- `references/gpu-friendly-math.md`: GPU 8-dimension acceptance gate
+- `agents/math-critic.md`: Math-engineering dual critic
+
+### 15 Thinking Lenses
+
+| Lens | File | Core Perspective |
+|------|------|-----------------|
+| Axiomatization | `lenses/axiomatization.md` | Audit assumptions for consistency/independence/completeness |
+| Duality | `lenses/duality.md` | Transform to dual space to expose constraints and invariants |
+| Symmetry | `lenses/symmetry.md` | Invariants and conservation laws under transformations |
+| Spectral | `lenses/spectral.md` | Eigenvalues/singular values reveal dominant structure |
+| Geometric | `lenses/geometric.md` | Metric/curvature/manifold spatial structure |
+| Projection | `lenses/projection.md` | Orthogonal decomposition, subspace separation, conflict elimination |
+| Variational | `lenses/variational.md` | Constrained extrema, energy minimization |
+| Local-to-Global | `lenses/local-to-global.md` | Assemble local properties into global structure |
+| Topological | `lenses/topological.md` | Continuous-deformation invariants, connectivity, holes |
+| Categorical | `lenses/categorical.md` | Universal properties, functors, natural transformations |
+| Perturbation | `lenses/perturbation.md` | Propagation of small perturbations, stability, robustness |
+| Causal | `lenses/causal.md` | Correlation ≠ causation, interventions, counterfactuals |
+| Game | `lenses/game.md` | Multi-agent strategic interaction, equilibrium, mechanism design |
+| Probabilistic | `lenses/probabilistic.md` | Quantify uncertainty, Bayesian updating |
+| Algorithmic | `lenses/algorithmic.md` | Complexity, feasibility, parallelism |
+
+### Knowledge Base (by math domain)
+
+| Domain | Cards |
+|--------|-------|
+| Matrix Analysis | projection, spectral-decomposition, low-rank-approximation, positive-semidefinite, matrix-perturbation |
+| Optimization | lagrangian-duality, convex-optimization, constrained-optimization, riemannian-optimization, proximal-method |
+| Differential Geometry | manifold, tangent-space, metric-tensor, geodesic, curvature, connection |
+| Lie Theory | group-action, lie-group, lie-algebra, representation, equivariance |
+| Topology | persistent-homology, euler-characteristic, fundamental-group |
+| Probability & Information | concentration-inequality, entropy, kl-divergence, information-bottleneck, fisher-information |
+| Information Geometry | natural-gradient, fisher-metric |
+
+### Design Patterns (by AI component)
+
+| Component | Patterns |
+|-----------|----------|
+| Attention | projection-attention, spectral-attention, equivariant-attention, geometry-aware-attention, information-bottleneck-attention |
+| Loss | orthogonality-loss, contrastive-loss, variational-loss, information-bottleneck-loss, constraint-penalty |
+| Routing | optimal-transport-routing, graph-routing, moe-routing, spectral-clustering-routing |
+| Representation | shared-private-decomposition, manifold-representation, equivariant-split, subspace-alignment |
+| Compression | low-rank-kv-cache, spectral-token-pruning, topology-preserving-compression, leverage-score-selection |
 
 ---
 
@@ -61,199 +108,144 @@ This skill packages sixteen core mathematical ideas into callable thinking frame
 
 ### Installation
 
-Just paste the following into Claude Code or any other terminal-style AI assistant:
-
 ```
 Please help me install math-skill: https://github.com/the-thinker0/math-skill, and show me how to use it
 ```
 
-Manual-install alternative (downloads the source; does not register the skill automatically):
+Manual install:
 
 ```bash
 git clone https://github.com/the-thinker0/math-skill.git
 ```
 
-Claude Code / Codex-style platforms: copy or symlink `skills/` and `commands/` according to the platform's skills / commands directory conventions, keeping `references/` at the same repo depth. Don't copy a single `SKILL.md` in isolation — `../../references/*` won't resolve.
-
-Cursor / other Markdown-rule platforms: treat `commands/*.md` as the manual entry points and `skills/*/SKILL.md` as the rule / skill body, and keep `references/`. If the platform has no auto-trigger mechanism, fire manually with `/ask` or the matching command.
-
-You can also inspect the npm package first:
-
-```bash
-npm pack math-skill --dry-run
-```
-
 ### Usage
 
-**Auto-trigger**: fires only when both conditions hold — (1) the workspace contains architecture core code (attention / transformer / MoE, `*.cu` / kernel, Triton) or research notes, AND (2) the user's task involves **designing / improving** new architectures / operators, **analyzing** theoretical properties, or **transferring** mathematical structures. Pure engineering tasks (debugging, argument-passing checks, refactoring, hyperparameter tuning, loss implementation tweaks) do not trigger.
-
-### Does it auto-trigger in normal chat?
-
-Yes, but it depends on whether the install platform supports **skill metadata auto-routing**. In skills-aware environments like Claude Code / Codex, you don't need `/ask` on every turn after installing. As of v2.0.1 the trigger has been tightened: the skill loads only when **both environment and task signals hit** — routine code review, debugging, and refactoring will not fire it.
-
-For example, you can simply ask:
-
-```
-I want to design a long-context attention that uses less KV-Cache — any modern math angle?
-```
-
-Or:
-
-```
-Can the memory access and fusion pattern of this Triton kernel be improved at the algorithmic-structure level?
-```
+**Auto-trigger**: The system auto-diagnoses user intent and routes to the appropriate layer:
 
-Such questions trigger `math-research-activator`, which loads `references/gpu-friendly-math.md` and `references/books/*.md` on demand. `/ask` and the slash commands below are the **explicit / fallback entry**: use them only when the platform has no auto-trigger, or when you want to force a specific thinking weapon.
+| Scenario | Signal | Path |
+|----------|--------|------|
+| Problem Analysis | "Is this design sound?" | Lenses → Critic |
+| Mechanism Design | "Design a new attention" | Lenses → Knowledge → Design → Critic |
+| Knowledge Query | "What is tangent space and how does it relate to gradient optimization?" | Knowledge |
+| Verification | "Does this formula hold?" | Knowledge → Critic |
+| Pure Engineering | debug, refactoring, tuning | **Not triggered** |
 
-**Manual fallback** (when in doubt, start with `/ask`):
+**Manual trigger**:
 
 ```
-/ask <your question>                     # activator: diagnose + map + route + GPU filter
-/axiomatization <your question>          # axiomatization
-/abstraction <your question>             # abstraction
-/logic-deduction <your question>         # logic deduction
-/modeling <your question>                # modeling
-/optimization <your question>            # optimization
-/probability-statistics <your question>  # probability & statistics
-/transformation <your question>          # transformation
-/symmetry-invariance <your question>     # symmetry & invariance
-/induction-analogy <your question>       # induction & analogy
-/algorithmic-thinking <your question>    # algorithmic thinking
-/information-theory <your question>      # information theory
-/game-theory <your question>             # game theory
-/causal-inference <your question>        # causal inference
-/topological-thinking <your question>    # topological thinking
-/discrete-combinatorial <your question>  # discrete & combinatorial thinking
+/ask <your question>     # Smart diagnosis: auto-detect scenario and route
 ```
 
 ### Language Switching
 
-Default output is **Chinese**. For **English** output, append `in English` to a command:
-
-```
-/optimization Is K-FAC feasible on H100 with this batch size? in English
-```
+Auto-detects user language: Chinese messages get Chinese output, English messages get English output.
 
 ---
 
-## Usage Examples
+## Workflow Example
 
-### Auto-trigger (research / algorithm / GPU)
+**User**: "Design a new KV Cache compression method that preserves long-range dependencies without just doing top-k"
 
-The activator steps in only when the workspace contains a kernel or attention core implementation **and the task involves design / analysis / transfer**: problem diagnosis, transferable modern-math structure candidates, weapon routing, 8-D GPU screening. Pure engineering tasks (debugging, code review, hyperparameter tuning) do not trigger. See the **Tropical Sheaf Attention** example in `skills/math-research-activator/SKILL.md`: it is a candidate exploration template, not a pre-baked benchmark result — it has to be validated on complexity, memory, low-precision stability, and kernel fusibility before adoption.
-
-### Manual trigger (research scenarios)
-
-**Review an algorithm's theoretical assumptions**:
-```
-/axiomatization This attention variant claims permutation invariance, yet its positional encoding smuggles in an implicit total order — is it self-consistent?
-```
-
-**Check a proof / invariant**:
-```
-/logic-deduction Does the step from line 5 to line 6 in this convergence proof skip a premise? Does the loop invariant hold?
-```
-
-**Optimizer / second-order feasibility**:
-```
-/optimization I want to replace Adam with K-FAC but memory is tight — is this second-order method feasible on GPU? Is there a retrofittable low-rank approximation?
-```
-
-**Change representation via transformation**:
-```
-/transformation Can this custom convolution operator be rewritten as a GEMM that fully saturates Tensor Cores? Is the inverse transform numerically stable?
-```
-
-**Equivariance / symmetry**:
 ```
-/symmetry-invariance Design an SO(3)-equivariant feature layer — can the group action be tensorized into a GEMM?
+Step 1  Diagnosis: Scenario B (Mechanism Design)
+  Problem type: sequence memory compression + information preservation + long-range structure
+  Core tension: compress token count vs. preserve long-range dependencies
+
+Step 2  Lens Selection:
+  1. Spectral (preserve dominant subspace)
+  2. Information-theoretic (preserve max mutual information states)
+  3. Topological (preserve key connection points in sequence structure)
+
+Step 3  Knowledge Query:
+  → low-rank-approximation (matrix analysis)
+  → leverage-score-selection (matrix analysis)
+  → information-bottleneck (probability & information)
+
+Step 4  Design Translation:
+  Candidate A: Spectral KV Compression (low-rank + leverage score)
+  Candidate B: Information-Preserving Cache (query sensitivity)
+  Candidate C: Topology-Preserving Cache (graph bridge node retention)
+
+Step 5  Critic Review:
+  A is most GPU-friendly, B needs future query estimation (uncertainty), C graph construction too expensive
+  Recommendation: prioritize A, use B as a lightweight gate
 ```
 
 ---
 
-## Progressive Disclosure
-
-| Layer | Content | Load timing |
-|-------|---------|-------------|
-| Resident trigger | `skills/math-research-activator/SKILL.md` + each weapon's short `description` | Loaded on auto / manual trigger |
-| Methodology | `references/agentic-workflow.md` (Human-in-the-Agent-Loop), `references/gpu-friendly-math.md` (8-D gate) | Referenced by activator on demand |
-| Book activation | `references/books/*.md` × 7 (modern-math structure distillations) | Loaded by problem type on demand |
-
-**Deep dive / look-up**: the distillations are self-sufficient. When you need the full original text and have `math_book/<PDF>` locally, let the agent run `pdftotext` + grep + Read on the matching page (no pre-embedded anchors required). PDFs are never bundled into npm / git (copyright + 110MB).
-
----
-
 ## Directory Structure
 
 ```
 math-skill/
-├── package.json             # v2.0.1, files[] includes references/
-├── .gitignore / .npmignore  # excludes math_book/ PDFs
-├── commands/                # manual slash-command entries (15 weapons + ask)
-├── skills/                  # 16 thinking weapons (15 weapons + math-research-activator)
-│   ├── math-research-activator/   # auto-trigger entry
-│   └── <weapon>/{SKILL.md, original-texts.md}
-├── references/              # v2 addition: methodology + book activation layer
-│   ├── agentic-workflow.md        # collaboration style
-│   ├── gpu-friendly-math.md       # 8-D GPU acceptance gate
-│   ├── inspiration.md             # inspiration
-│   └── books/                     # 7 modern-math distillations
-├── agents/math-critic.md    # critic agent (18 dimensions, incl. GPU + modern-math activation)
-├── knowledge-base/overview.md
-├── tests/{validate.sh, validate.ps1}
-├── math_book/               # local PDFs (ignored by git/npm, not published)
+├── skills/
+│   └── math-research-activator/    # Orchestrator: intent diagnosis + routing
+├── lenses/                         # 15 thinking lenses (reasoning methodology)
+├── knowledge-base/                 # Math knowledge (by domain)
+│   ├── matrix-analysis/            # Matrix analysis (5 cards)
+│   ├── optimization/               # Optimization (5 cards)
+│   ├── differential-geometry/      # Differential geometry (6 cards)
+│   ├── lie-theory/                 # Lie theory (5 cards)
+│   ├── topology/                   # Topology (3 cards)
+│   ├── probability/                # Probability & information (5 cards)
+│   └── information-geometry/       # Information geometry (2 cards)
+├── design-patterns/                # Design translation (by AI component)
+│   ├── attention/                  # Attention mechanisms (5 patterns)
+│   ├── loss/                       # Loss functions (5 patterns)
+│   ├── routing/                    # Routing (4 patterns)
+│   ├── representation/             # Representation (4 patterns)
+│   └── compression/                # Compression (4 patterns)
+├── references/                     # Reference layer
+│   ├── books/                      # 7 book distillations
+│   ├── gpu-friendly-math.md        # GPU 8-dimension gate
+│   ├── agentic-workflow.md         # Collaboration style
+│   └── inspiration.md              # Inspiration
+├── agents/math-critic.md           # Math-engineering dual critic
+├── commands/ask.md                 # /ask manual entry
+├── math_book/                      # Local PDFs (not published)
 └── README.md / LICENSE
 ```
 
 ---
 
-## What Each Skill Contains
-
-Each `skills/*/SKILL.md` (v2 single research / algorithm path):
+## Recommended Books
 
-1. **Core principle** + blockquote sub-section **Mathematical Formalization** (definitions / theorems / formulas)
-2. **GPU friendliness (cross-cut check)** — how this weapon's structure maps to GPU, passing the 8-D gate
-3. **When NOT to use** / **When to use** (research trigger, including algorithm / operator-design usage)
-4. **Method flow** — single research path (all math retained)
-5. **Common mistakes** — including a one-liner on GPU computability
-6. **Operating procedure** — single output format, ending with a `[GPU Feasibility]` item
-7. **Relationship to other skills** — includes a "modern math activation" row, pointing to `references/books/*`
+| # | Title | Author(s) | Publisher / Edition | Year | ISBN | Distillation |
+|---|-------|-----------|-------------------|------|------|-------------|
+| 1 | *Contemporary Abstract Algebra* | Joseph A. Gallian | Brooks/Cole, Cengage, 8th ed. | 2013 | 978-1-133-59971-5 | `abstract-algebra.md` |
+| 2 | *The Rising Sea: Foundations of Algebraic Geometry* | Ravi Vakil | Princeton University Press | 2025 | 978-0-691-26866-8 | `algebraic-geometry-rising-sea.md` |
+| 3 | *Manifolds and Differential Geometry* | Jeffrey M. Lee | AMS, Graduate Studies in Math Vol. 107 | 2009 | 978-0-8218-4815-9 | `differential-geometry.md` |
+| 4 | *Matrix Analysis* | Roger A. Horn, Charles R. Johnson | Cambridge University Press, 2nd ed. | 2013 | 978-0-521-83940-2 | `matrix-analysis.md` |
+| 5 | *A micro Lie theory for state estimation in robotics* | Joan Solà et al. | arXiv:1812.01537v9 | 2021 | — | `micro-lie-theory.md` |
+| 6 | *An Introduction to Optimization, With Applications to ML* | Chong, Lu, Żak | John Wiley & Sons, 5th ed. | 2024 | 978-1-119-87763-9 | `optimization-ml.md` |
+| 7 | *Introduction to Smooth Manifolds* | John M. Lee | Springer, GTM 218, 2nd ed. | 2013 | 978-1-4419-9981-8 | `smooth-manifolds.md` |
 
-Each weapon also ships an `original-texts.md` (math sources and classical references). Outputs can be sent to `agents/math-critic.md` (18 dimensions, including GPU feasibility + modern-math activation) for a second pass.
+Distillation files ship with the npm package. For full-fidelity lookups, place PDFs in the `math_book/` folder.
 
 ---
 
-## Mathematical Knowledge System
-
-`knowledge-base/overview.md` provides a math knowledge map: three pillars (algebra / geometry / analysis), main branches, knowledge layers (foundation → algebra → synthesis → frontier), and the mapping from thinking weapons to math branches.
+## Changelog
 
----
+### v3.0.0 — Mathematical Research Operating System
 
-## Inspiration
+**Architecture overhaul**: from "thinking weapon arsenal" to "math general staff" — three-layer orthogonal architecture:
 
-The story of Sophus Lie forging a "dragon-slaying blade" tells us this: the Lie group–Lie algebra machinery invented to solve differential equations ended up becoming the lingua franca for describing symmetry and robot state estimation — the value of a mathematical tool far outlives its original intent, which is exactly the prototype of "cross-domain activation." See [`references/inspiration.md`](references/inspiration.md).
+- **Thinking Lenses** (15): slimmed down from v2's "thinking weapons" — reasoning methodology only, no concrete math knowledge mixed in
+- **Knowledge Base** (31 cards): concrete math tools organized by domain, with definitions/formulas/AI design translation/GPU feasibility
+- **Design Translation Layer** (new): the bridge from math to AI modules, organized by AI component (attention/loss/routing/representation/compression)
+- **Activator rewrite**: from environment-signal matching to intent diagnosis (5 scenarios: analysis/design/query/verification/engineering)
+- **Knowledge activation protocol**: fixed output format for knowledge cards (minimal definition → formula → applicable problems → AI translation → engineering feasibility → risks)
 
----
-
-## Changelog
+### v2.1.0 — Full Bilingual Support
+- 37 .en.md files, auto language routing, same commands for both languages, no double token cost
 
 ### v2.0.1
-- **Tightened auto-trigger conditions**: `math-research-activator` changed from "any environment OR conversation signal hits → trigger" to "environment AND task signals must both hit" (Gate 1 + Gate 2 as dual necessary conditions).
-- **Added an exclusion gate (Gate 0)**: pure engineering tasks — code review, debugging, argument-passing checks, refactoring, hyperparameter tuning, loss implementation tweaks — are now on an explicit exclusion list with the highest priority.
-- **Narrowed environment signals**: mere `model.py`, `trainer.py`, `config.json` and other routine ML engineering files no longer count as environment signals; architecture core code (attention / transformer / MoE, CUDA / Triton kernel) or research notes is required.
-- **Updated `description` field**: explicitly lists "does not trigger on" scenarios, reducing skill metadata mis-matches on AI platforms.
+- Tightened auto-trigger conditions, added exclusion gate, narrowed environment signals
 
 ### v2.0.0
-- Initial v2 release: 16 thinking weapons, modern-math activation layer, 8-D GPU cross-cut, progressive disclosure.
+- 16 thinking weapons, modern math activation layer, GPU 8-D cross-cut
 
 ### v1.0.0
-- Initial release: fifteen thinking weapons (axiomatization / abstraction / logic deduction / modeling / optimization / probability & statistics / transformation / symmetry & invariance / induction & analogy / algorithmic thinking / information theory / game theory / causal inference / topology / discrete & combinatorial) + dual research-and-life paths.
-- Fifteen `skills/*/SKILL.md` files (core principle, when-not-to-use, method flow, common mistakes, operating procedure) + matching `original-texts.md` (math sources and classical references).
-- Fifteen manual slash-command entries (`commands/*.md`).
-- `knowledge-base/overview.md` (three pillars / main branches / knowledge layers / weapon mapping).
-- `agents/math-critic.md` critic agent.
-- Validation scripts `tests/{validate.sh, validate.ps1}`.
-- Published to npm (`math-skill`), MIT license.
+- Initial release: fifteen thinking weapons + dual research/life paths
 
 ---
 
@@ -265,7 +257,7 @@ MIT License. See `LICENSE`.
 
 ## Contributing
 
-Issues and Pull Requests are welcome — let's learn and build together!
+Issues and Pull Requests are welcome!
 
 ---