math-skill 2.1.0 → 3.0.1

package/skills/abstraction/original-texts.md

@@ -1,175 +0,0 @@
-# 数学出处与经典文献 / Mathematical Sources and Classic Texts
-
-## 伽罗瓦理论 / Galois Theory (1830s)
-
-> "伽罗瓦理论的深刻之处在于：它将'方程是否有根式解'的问题，转化为'置换群是否可解'的结构问题。"
-> "The profundity of Galois theory: it transforms the question 'can an equation be solved by radicals?' into the structural question 'is the permutation group solvable?'"
-
-**抽象范式**：伽罗瓦理论是数学史上最早的系统抽象——从具体的方程求解，上升到群的对称性结构。
-- 根的置换群（permutation group of roots）决定了方程的可解性
-- 伽罗瓦对应（Galois correspondence）：子群 ↔ 子域，将代数与结构直接联系
-- 影响深远：开启了"用结构代替计算"的思维方式，为抽象代数奠定基础
-
-**历史**：Evariste Galois (1811–1832)，生前未获认可，手稿由 Liouville 于 1846 年发表。
-
-## 戴德金与诺特 / Dedekind & Noether — 从数到结构 / From Numbers to Structures
-
-> "戴德金将整数从'计数工具'抽象为'环的理想'；诺特将这一切系统化，使理想成为代数的核心对象。"
-> "Dedekind abstracted integers from 'counting tools' into 'ideals of rings'; Noether systematized this, making ideals the central objects of algebra."
-
-**关键贡献**：
-- **Dedekind (1831–1916)**：理想（ideals）理论的创始人——将"整除"抽象为"包含关系"，将数论提升到结构层面
-- **Emmy Noether (1882–1935)**：
-  - 诺特环（Noetherian rings）：升链条件将"有限性"从具体对象抽象为结构性质
-  - 诺定理（Noether's theorem, 1918）：物理中的对称性 ↔ 守恒律——物理学中抽象结构的典范
-  - 将抽象代数从"计算性"转向"结构性"
-
-> "Noether 的教学模式：'Es steht schon bei Dedekind'（Dedekind 已经写过了）——她总是追溯结构的思想根源。"
-
-## 范畴论 / Category Theory (Eilenberg & Mac Lane, 1945)
-
-> "范畴论的核心思想是：研究对象之间的态射（映射）比研究对象本身更重要。"
-> "The key idea of category theory: studying the morphisms (maps) between objects is more important than studying the objects themselves."
-
-**核心概念**：
-- **对象（Objects）** 和 **态射（Morphisms）**
-- **函子（Functors）**：范畴之间的映射
-- **自然变换（Natural Transformations）**：函子之间的映射
-- **泛性质（Universal Properties）**：用关系定义对象
-
-**抽象的意义**：范畴论是"数学的数学"——它抽象到可以描述数学本身的结构。
-
-## 米田引理 / Yoneda Lemma (1954)
-
-> "一个对象完全由它与其他对象之间的关系所决定——这是范畴论的基本定理。"
-> "An object is completely determined by its relationships to all other objects — this is the fundamental theorem of category theory."
-
-**数学含义**：
-- 形式化表述：Hom(Hom(A, —), F) ≅ F(A)——函子的自然变换与函子在 A 处的取值一一对应
-- 哲学意义：要了解一个事物，只需观察它与一切其他事物的交互——"你由你的关系所定义"
-- Yoneda 嵌入：每个对象 A ↦ Hom(—, A)，对象可完全嵌入到其"关系世界"中
-- 被称为范畴论的"第一定理"（first theorem），地位相当于集合论中的外延公理
-
-**历史**：首次出现在 Nobuo Yoneda 的未发表笔记中，后由 Mac Lane 在 1954 年正式阐述。
-
-## 布尔巴基 / Bourbaki (1935–)
-
-> "布尔巴基用'结构'作为统一语言重写了二十世纪数学——从母结构（代数、序、拓扑）出发，一切皆结构。"
-> "Bourbaki rewrote 20th-century mathematics with 'structures' as a unifying language — from mother structures (algebra, order, topology), everything is structure."
-
-**核心思想**：
-- 三大母结构（mother structures）：代数结构（algebraic）、序结构（order）、拓扑结构（topological）
-- 复合结构（multiple structures）：由母结构组合而来——拓扑群、有序域等
-- 《数学原理》（Éléments de mathématique）：40 余卷的系统化重写
-- 影响深远：定义了现代数学教材的组织方式与抽象风格
-
-**争议**：布尔巴基的结构主义偏向过于抽象，忽视了概率论与计算数学——但也正是这种抽象化推动了范畴论的诞生。
-
-## 代数结构 / Algebraic Structures
-
-抽象代数展示了不同数学对象之间的深层共性：
-
-| 结构 | 运算要求 | 例子 |
-|------|---------|------|
-| 半群 (Semigroup) | 封闭、结合 | 函数复合、字符串拼接 |
-| 幺半群 (Monoid) | 半群 + 单位元 | 自然数加法、列表拼接（含空列表） |
-| 群 (Group) | 幺半群 + 逆元 | 对称群、整数加法群 |
-| 环 (Ring) | 群（加法）+ 半群（乘法）+ 分配律 | 整数环、多项式环 |
-| 域 (Field) | 环 + 乘法逆元（非零元） | 有理数域、实数域 |
-| 向量空间 (Vector Space) | 域上的加法群 + 标量乘法 | ℝⁿ, 函数空间 |
-
-**中间结构的意义**：半群和幺半群并非"不完整的群"——它们在自动机理论（automata theory）、形式语言（formal languages）、字符串处理中本身就是核心对象。抽象不是追求"最完整"，而是提取恰好所需的性质。
-
-**抽象的力量**：一旦在抽象层面证明了某个结论，它就自动适用于所有满足该结构的实例。
-
-## 泛代数 / Universal Algebra (Birkhoff, 1935)
-
-> "泛代数的核心问题是：什么样的等式类（equational classes）可以被一组等式公理所定义？"
-> "The central question of universal algebra: which equational classes can be defined by a set of equational axioms?"
-
-**关键贡献**：
-- **Birkhoff 定理**：一个代数类是等式类（variety） iff 它对同态像、子代数、直积封闭（HSP 定理）
-- 系统地研究"代数结构本身"——不是某个具体群或环，而是"一切满足给定公理的结构的共同性质"
-- 泛代数是范畴论的前驱：泛性质、自由对象等概念在此已经有了雏形
-- 与范畴论的关系：等式类 = 由自由代数生成的范畴中的泛对象
-
-## 表示论 / Representation Theory (Frobenius, 1896–)
-
-> "表示论将抽象群'实现'为具体的线性变换——让不可见的对称性变得可见。"
-> "Representation theory 'realizes' abstract groups as concrete linear transformations — making invisible symmetries visible."
-
-**核心思想**：
-- 群表示（group representation）：群 G → GL(V)，将抽象群元素映射为矩阵
-- Frobenius (1849–1917)：开创群的特征标理论（character theory），用迹函数捕捉不可约表示
-- 不可约表示（irreducible representations）：群的"原子"——一切表示由它们组合
-- Schur 引理、Maschke 定理等构成了半单代数的完整理论
-
-**抽象的双重意义**：一方面，表示论让抽象对象变得可计算；另一方面，表示的分类本身就是更高层次的抽象问题。
-
-## 自由对象与泛构造 / Free Objects and Universal Constructions
-
-> "自由对象是'没有任何额外关系'的最一般的对象——它仅由公理强制的关系所决定。"
-> "A free object is the most general object with 'no extra relations' — determined only by relations forced by axioms."
-
-**核心概念**：
-- **自由群（Free group）**：由字母表生成，除群的公理外无任何额外关系
-- **自由幺半群（Free monoid）**：就是字符串集合——字符串拼接是"最自由的"结合运算
-- **泛性质表述**：自由对象 F(A) 满足——任意映射 A → X（X 为目标结构中的对象）唯一延伸为 F(A) → X 的态射
-- **左伴随（Left adjoint）**：遗忘函子（forgetful functor）的左伴随就是自由对象——抽象的"最一般解"
-
-**意义**：自由对象展示了泛构造的典型模式——用"最少的约束"定义"最一般的解"，然后通过附加关系得到更具体的对象。
-
-## 格罗滕迪克与概形 / Grothendieck & Schemes (1950s–60s)
-
-> "格罗滕迪克将代数几何彻底重构：不再研究具体曲线，而是研究概形——最一般的'空间'概念。"
-> "Grothendieck completely reconstructed algebraic geometry: no longer studying specific curves, but schemes — the most general notion of 'space'."
-
-**革命性抽象**：
-- **概形（Schemes）**：将代数簇（algebraic varieties）推广到允许零因子、任意基的改变——"空间"不再是点集，而是环的谱（spectrum of a ring）
-- **拓扑斯（Topoi）**：比拓扑空间更一般的"空间"概念——一个拓扑斯就是一个范畴，足以支撑内部逻辑
-- **动机（Motives）**：猜想中的"万能上同调理论"——不同上同调理论的共同根源
-- **泛构造哲学**：Grothendieck 总是先找到"最一般"的框架，再在其中解决具体问题
-
-**影响**：EGA/SGA 四千余页的重写，使代数几何成为最抽象也最强大的数学分支之一。Weil 猜想（Weil conjectures）的证明正是这一抽象框架的直接成果。
-
-## 拓扑学 / Topology
-
-> "拓扑学是研究在连续变形下保持不变的性质的学科。"
-> "Topology studies properties that remain unchanged under continuous deformations."
-
-**抽象层次**：
-- 度量空间 → 拓扑空间：去掉距离，只保留"开集"概念
-- 连续函数 → 态射：去掉 ε-δ，只保留"开集的原像是开集"
-- 同胚 → 等价：拓扑意义下"相同"的空间
-
-**经典案例**：咖啡杯和甜甜圈在拓扑意义下是同构的——它们都有一个洞。
-
-## 同伦类型论 / Homotopy Type Theory (Voevodsky, 2009–)
-
-> "同伦类型论的唯一性公理宣称：同构的结构就是相同的——这是抽象的终极形式。"
-> "The univalence axiom of homotopy type theory asserts: isomorphic structures are identical — the ultimate form of abstraction."
-
-**核心思想**：
-- **唯一性公理（Univalence Axiom）**：(A ≃ B) ≃ (A = B)——同构与相等等价
-- 哲学冲击：如果两个结构在所有可观测性质上一致，它们就"是"同一个——没有"不可观测的"同一性
-- **同伦层级（h-levels）**：命题（h-level 1）、集合（h-level 2）、群对象（h-level 3）……——将经典逻辑与拓扑直觉统一
-- Voevodsky (1966–2017)：Fields 奖得主，后期致力于将数学建立在计算可靠性更高的新基础之上
-
-**与范畴论的关系**：同伦类型论可视为范畴论的"内部语言"——在 (∞,1)-范畴的语境中，唯一性公理是自然的。
-
-## 抽象的本质 / The Nature of Abstraction
-
-> "所谓抽象，就是忽略具体的、偶然的特征，提取一般的、本质的结构。"
-> "Abstraction means ignoring specific, contingent features and extracting general, essential structures."
-
-抽象不是远离现实，而是深入现实——通过找到不同事物的共同结构，我们可以用统一的框架处理它们。
-
-**抽象的谱系**：
-- Galois (1830s)：方程 → 群结构
-- Dedekind (1870s)：数 → 理想
-- Birkhoff (1935)：具体代数 → 等式类
-- Eilenberg–Mac Lane (1945)：具体数学 → 范畴
-- Grothendieck (1960s)：具体空间 → 概形与拓扑斯
-- Voevodsky (2010s)：同构 → 同一
-
-每一次抽象，都让我们看到更深的结构，处理更广的问题。

package/skills/algorithmic-thinking/SKILL.en.md

@@ -1,132 +0,0 @@
----
-name: algorithmic-thinking
-description: |
-  Trigger when a problem needs finite-step solving, algorithm design, complexity analysis (time/space), tractability & parallelism assessment (P/NP-hard/undecidable); or termination/correctness proofs; or designing executable algorithms/operators for GPU (assessing complexity order, parallelism, memory access & fusion).
----
-
-# 🖥️ Algorithmic Thinking
-
-> "An algorithm is the automation of thought — turning insight into precisely repeatable steps."
->
-> — Computability Theory, Algorithm Analysis, Complexity Theory
-
-## Core Principle
-
-**Break problems into executable steps, assess cost, judge feasibility. The first principle is not "how to solve" but "whether it is solvable and at what cost" — some problems are inherently hard (NP-complete), some inherently unsolvable (undecidable); knowing these limits is as important as finding solutions.**
-
-> **Mathematical Formalization**
->
-> A Turing machine M: Σ* → Σ* halts within a finite number of steps. Time complexity T(n) = the maximum number of execution steps for an input of length n; space complexity S(n) = the maximum number of cells used. Church–Turing thesis: anything computable is computable by a Turing machine.
->
-> Three-tier hierarchy: computable (an algorithm exists) → tractable (a polynomial-time algorithm exists) → intractable (only exponential-time or no algorithm). Computable but intractable is practically equivalent to uncomputable — brute force 2^n is worthless for n=100. P vs NP is precisely the boundary between tractable and intractable.
->
-> Complexity notation: O(f(n)) upper bound, Ω(f(n)) lower bound, Θ(f(n)) tight bound. Common recurrences: T(n)=2T(n/2)+O(n) → O(n log n); T(n)=T(n-1)+O(n) → O(n²); T(n)=T(n/2)+O(1) → O(log n). Complexity classes: O(1) ⊂ O(log n) ⊂ O(n) ⊂ O(n log n) ⊂ O(n^k) ⊂ O(2^n) ⊂ O(n!).
->
-> Complexity class definitions: P = polynomial-time decidable; NP-hard = at least as hard as every problem in NP; undecidable = no algorithm can decide it. NP-hard response: approximation (with error bounds) or heuristics (with probabilistic guarantees); undecidable response: find a decidable restricted version.
->
-> Loop invariant: a property that holds before and after every iteration, which together with the termination condition implies output correctness. Hoare logic: {P} S {Q} — precondition P, after statement S, yields postcondition Q.
-
-## GPU-Friendliness (Cross-Cutting Check)
-
-Algorithmic thinking is the weapon most directly relevant to GPU — complexity order, parallelism, memory access/communication, and operator fusion directly determine whether an algorithm can run efficiently on GPU. Every algorithm must pass the `../../references/gpu-friendly-math.md` eight-dimension gate:
-
-- **Complexity order**: Sub-quadratic O(n log n)/O(n) is friendly (fully utilizes parallel cores); O(n²) is borderline (GEMM is an exception, salvageable by Tensor Cores); O(2^n)/O(n!) is an anti-pattern.
-- **Parallelism and communication**: Divide-and-conquer / data parallelism is friendly (sub-problems are independent, batchable); dependency chains in dynamic programming and serial search in backtracking require adaptation (chunking / skew scanning).
-- **Memory and KV-Cache / Parallelism and communication**: Coalesced access is friendly; butterfly reductions and prefix scans have dependency patterns that require attention to bandwidth; random scatter/gather is unfriendly.
-- **Operator fusion**: Multiple elementwise steps can be fused into a single kernel; algorithms that repeatedly read/write to memory — "beautiful but intractable" — should be rearranged into a single pass.
-
-Eight-dimension minimum criteria (formal terms): **Tensorization** requires the main loop to be batchable; **GEMM-mappability** prioritizes expressing the core computation as GEMM/conv/scan; **complexity** must specify both time and space order; **memory and KV-cache** checks whether intermediate tables, state, and cache can be chunked; **low-precision stability** checks reduction, sorting, and iteration errors; **parallelism and communication** checks dependency graphs and cross-device synchronization; **sparse structure** accepts only structured sparsity; **operator fusion** requires reducing small kernels and memory round-trips.
-
-| Algorithm characteristic | GPU classification | Notes |
-|---|---|---|
-| Divide-and-conquer / Merge / FFT | Friendly | Sub-quadratic, batchable, regular structure |
-| Dynamic programming (dependency chains) | Adaptable | Chunking / skew scanning breaks serial dependencies |
-| Backtracking / DFS serial search | Anti-pattern | Unpredictable branching, cannot fill SIMD lanes |
-| Brute force O(2^n) | Anti-pattern | Complexity order itself is intractable |
-
-> Used together with `../../references/books/matrix-analysis.md` (GEMM / low-rank decomposition for order reduction), `../../references/books/optimization-ml.md` (first-order / second-order method feasibility), `../../references/books/abstract-algebra.md` (parallel algorithms over semirings / finite fields).
-
-## When NOT to Use
-
-- **The problem has a closed-form solution and does not require step-by-step computation** — e.g., the quadratic formula directly gives the answer; algorithmic treatment only adds complexity.
-- **The problem is qualitative rather than procedural** — e.g., "Is this structure elegant?" or "Is this proof insightful?" cannot be reduced to finite steps.
-- **The input is unstructured and cannot be discretized** — e.g., a continuous perceptual data stream cannot directly serve as algorithm input; when preprocessing is more complex than the core problem, algorithmic treatment may not be optimal.
-
-## When to Use
-
-- Automating a repetitive process — the same operation must be performed on large volumes of data; manual execution does not scale.
-- Verifying program termination — proving the algorithm halts in a finite number of steps is the cornerstone of reliability.
-- Estimating computational cost — evaluating time/space consumption before large-scale runs to avoid resource exhaustion.
-- Facing combinatorial explosion — the search space grows exponentially with input size, requiring pruning strategies.
-- Judging problem feasibility — determining P / NP-hard / undecidable to decide on a solution strategy.
-- Designing efficient solution procedures — from brute force to elegant algorithms, efficiency differences can span several orders of magnitude.
-- **Designing executable algorithms/operators for GPU** — assessing complexity order, parallelism, memory access, and fusion so the algorithm is truly tractable on hardware.
-
-## Method
-
-### Step 1: Formalize I/O Spec
-Define the input domain, output domain, and constraints. The input specification states data types (integer/floating-point/string/graph), scale range n∈[1,10^6], and validity conditions (preconditions); the output specification states the return type, precision, and boundary handling; constraints cover time/space limits and correctness guarantees (postconditions). Test: if you cannot write down the precondition/postcondition predicates, the specification is not yet formal enough.
-
-### Step 2: Decompose into Sub-problems
-Break the large problem into independently solvable pieces with clear boundaries and well-defined interfaces. Decomposition strategies: by data (processing different subsets), by function (completing different subtasks), by level (coarse-to-fine refinement). Good decomposition makes each sub-problem independently verifiable and the whole recursively verifiable; dependencies between sub-problems must be explicitly annotated to avoid implicit coupling.
-
-### Step 3: Design the Procedure
-Choose an algorithmic paradigm — this is the core decision; choosing wrong wastes all subsequent effort:
-
-- **Divide-and-Conquer**: Partition, solve sub-parts, merge. Sub-problems are independent; merge cost is lower than solving the whole. Classics: merge sort, quicksort, Strassen matrix multiplication. Recurrence T(n)=aT(n/b)+f(n), solved by the Master Theorem.
-- **Dynamic Programming (DP)**: Overlapping sub-problems, memoization to avoid repetition. Optimal substructure holds. Classics: shortest paths, knapsack, sequence alignment.
-- **Greedy**: Locally optimal at each step, hoping for global optimality. Greedy-choice property holds. Classics: Dijkstra, Huffman, MST.
-- **Backtracking**: Systematic search, pruning and retreating upon hitting dead ends. Search space has structure. Classics: N-queens, exact TSP, CSP.
-- **Randomized**: Probabilistic shortcuts, trading randomness for efficiency. Deterministic cost is too high. Classics: randomized quicksort, Monte Carlo, Las Vegas.
-
-Selection principle: independent → divide-and-conquer; overlapping → DP; greedy property → greedy; structured search → backtracking; deterministic cost too high → randomized. Practical problems often mix multiple paradigms.
-
-### Step 4: Analyze Complexity
-Time O(f(n)), space O(g(n)), distinguishing worst case from average case. Identify basic operation counts, solve recurrences (Master Theorem), and attend to how input distributions affect average-case complexity; beyond O (upper bound), attend to Ω (lower bound) and Θ (tight bound). Complexity analysis is an ongoing assessment during design, not post-hoc verification. Practical significance: for n=10^6, O(n) ≈ 10^6 steps (seconds), O(n²) ≈ 10^12 steps (infeasible), O(2^n) far exceeds the age of the universe.
-
-### Step 5: Prove Correctness
-Use loop invariants, structural induction, termination proofs, and pre/postconditions. An unverified algorithm is a guess. Loop invariant: initialization (holds before the loop), maintenance (preserved by each iteration), termination (invariant plus termination condition yields the postcondition); structural induction: assume correctness of sub-calls and prove the current call; termination: construct a decreasing measure and prove it strictly decreases; Hoare logic: {P} S {Q}.
-
-### Step 6: Check Tractability
-Is the problem in P? NP-hard? Undecidable? P → pursue the optimal exact algorithm; NP-hard → approximation/heuristics with explicit error bounds or probabilistic guarantees; undecidable → find a decidable restricted version. Common NP-hard problems: TSP, graph coloring, subset sum, SAT; common undecidable problems: the halting problem, Hilbert's tenth problem.
-
-### Step 7: Optimize and Improve
-Reduce constant factors, leverage data structures, parallelize — based on bottleneck analysis, not blind tuning. Optimization levels: (1) Algorithm level — switch to a superior paradigm (O(n²) → O(n log n) yields the largest gain); (2) Data structure level — switch to better storage/query structures; (3) Implementation level — caching, parallelism, SIMD, operator fusion; (4) Problem level — reformulate for easier solving (may yield qualitative leaps). Priority: algorithm level > data structure level > implementation level; problem level may enable leaps. Re-verify correctness after every optimization.
-
-## Common Errors
-
-| Error | Critique | Correct Approach |
-|-------|----------|-----------------|
-| Assuming exponential algorithms are acceptable | NP-hard problems require heuristics for large n, not exact solutions; 2^50 steps at 1ns each takes 35 years | Use approximation/heuristics for large n with explicit error bounds |
-| Failing to prove termination | Infinite loops are a real risk; hanging is far more dangerous than slow results | Prove termination via a decreasing measure; construct a decreasing function on a well-ordered set |
-| Confusing worst case with average case | Quicksort is worst-case O(n²) but average O(n log n); the worst case can occur in practice | Clearly state the analysis scenario and note assumptions |
-| Confusing existence with constructibility | A solution may exist but be uncomputable; existence ≠ constructibility | Distinguish existence proofs from algorithmic constructions |
-| Underestimating constant factors | O(n log n) with a huge constant may be slower than O(n²) with a small constant | Benchmark empirically; attend to constants and cache effects |
-| Ignoring space complexity | A time-efficient algorithm may exhaust memory; DFS needs O(n) but BFS needs O(2^n) | Analyze both time and space |
-| Premature optimization | Optimizing before proving correctness; the direction may be entirely wrong | Prove correctness first → analyze complexity → then optimize |
-| Ignoring input distribution | Average-case complexity depends on distributional assumptions; random input ≠ real input | State distributional assumptions explicitly; analyze real-world scenarios |
-| Serial / unfusable algorithms on GPU | Unpredictable branching, serial dependency chains, repeated memory reads/writes — "beautiful but intractable" | Adapt to parallel / fusible / sub-quadratic form; pass the GPU eight-dimension gate |
-
-## Operating Procedure
-
-When this skill is triggered, the output must include:
-
-1. **Input specification**: `[Input]: [description]` — e.g., `[Input]: unsorted integer array A[1..n], n∈[1,10^6]`
-2. **Output specification**: `[Output]: [description]` — e.g., `[Output]: A sorted in ascending order`
-3. **Algorithm paradigm**: `[Paradigm]: [divide-and-conquer/DP/greedy/backtracking/randomized] because [reason]`
-4. **Complexity**: `[Time]: O([f(n)]) [Space]: O([g(n)]) [Scenario]: [worst/average]`
-5. **Correctness**: `[Loop invariant/induction strategy]: [content] ✅ proved / ❌ not proved`
-6. **Tractability**: `[Class]: [P/NP-hard/undecidable] [Response]: [exact/approximate/heuristic/reformulate]`
-7. **Improvement suggestions**: `[Optimization direction]: [specific suggestions]`
-8. **[GPU feasibility]** (if used for algorithm/operator design) — complexity order / parallelism / memory access / fusion assessment, annotate as friendly / retrofittable / anti-pattern + adaptation suggestions
-
-**The output must not present analysis alone without a conclusion.**
-
-## Relations to Other Skills
-
-- **Optimization thinking**: Gradient descent, branch-and-bound, and other optimization algorithms are instances of algorithmic thinking — optimization focuses on the optimal value, while algorithms focus on the steps and cost to reach it.
-- **Transformation thinking**: FFT is a paradigmatic application of algorithmic thinking to transformations — O(n²) → O(n log n); transformations map problems to easily solvable spaces, and algorithms solve them efficiently in the transformed space.
-- **Logical deduction**: Correctness proofs use deductive reasoning (loop invariants, induction) — an algorithm correctness proof is essentially a chain of deductive steps.
-- **Induction and analogy**: Divide-and-conquer uses structural analogy — sub-problems are isomorphic to the original problem — which is precisely the algorithmic embodiment of inductive thinking.
-- **Discrete / Combinatorial thinking**: Algorithms process discrete objects, and combinatorial counting underpins complexity analysis — combinatorial explosion is the core obstacle algorithmic thinking must overcome.
-- **Modern mathematics activation**: `../../references/books/matrix-analysis.md` (GEMM / low-rank decomposition for order reduction), `../../references/books/optimization-ml.md` (GPU feasibility of first-order / second-order methods), `../../references/books/abstract-algebra.md` (parallel algorithms over semirings / finite fields).

package/skills/algorithmic-thinking/SKILL.md

@@ -1,138 +0,0 @@
----
-name: algorithmic-thinking
-description: |
-  触发：问题需要有限步骤求解、算法设计、复杂度分析（时间/空间）、可行性与并行性评估（P/NP-hard/不可判定）；或需证明终止性/正确性；或为 GPU 设计可执行算法/算子（评估复杂度阶、并行度、访存与融合）时调用。
-  English: Trigger when a problem needs finite-step solving, algorithm design, complexity analysis (time/space), tractability & parallelism assessment (P/NP-hard/undecidable); or termination/correctness proofs; or designing executable algorithms/operators for GPU (assessing complexity order, parallelism, memory access & fusion).
----
-
-> **语言路由**：若用户消息为英文，请读取并遵循同目录下的 `SKILL.en.md`，按其操作规程以英文输出；中文消息则继续使用本文件。
-
-# 🖥️ 算法与计算思想 / Algorithmic Thinking
-
-> "算法是思想的自动化——将洞察转化为可重复执行的精确步骤。"
-> "An algorithm is the automation of thought — turning insight into precisely repeatable steps."
->
-> —— 计算理论、算法分析、复杂度理论 / Computability Theory, Algorithm Analysis, Complexity Theory
-
-## 核心原则 / Core Principle
-
-**把问题拆解为可执行步骤，评估代价，判断可行性。算法思想的第一原则不是"如何求解"，而是"是否可解、代价几何"——某些问题本质困难（NP 完全），某些本质不可解（不可判定），了解这些极限与找到解同样重要。**
-
-**Break problems into executable steps, assess cost, judge feasibility. The first principle is not "how to solve" but "whether it is solvable and at what cost" — some problems are inherently hard (NP-complete), some inherently unsolvable (undecidable); knowing these limits is as important as finding solutions.**
-
-> **数学形式化 / Mathematical Formalization**
->
-> 图灵机 M: Σ* → Σ* 在有限步骤内停机。时间复杂度 T(n) = 长度为 n 的输入的最大执行步数；空间复杂度 S(n) = 最大使用单元数。丘奇-图灵论题：任何可计算的都可由图灵机计算。
->
-> 三级层次：可计算（算法存在）→ 可行（多项式时间算法存在）→ 难解（仅指数时间或无算法）。可计算但不可行在实践中等同不可计算——蛮力 2^n 对 n=100 毫无价值。P vs NP 正是可行与难解的分界。
->
-> 复杂度符号：O(f(n)) 上界，Ω(f(n)) 下界，Θ(f(n)) 精确界。常见递推：T(n)=2T(n/2)+O(n)→O(n log n)；T(n)=T(n-1)+O(n)→O(n²)；T(n)=T(n/2)+O(1)→O(log n)。复杂度类：O(1)⊂O(log n)⊂O(n)⊂O(n log n)⊂O(n^k)⊂O(2^n)⊂O(n!)。
->
-> 复杂度类定义：P = 多项式时间可判定；NP-hard = 至少与所有 NP 问题同等困难；不可判定 = 无任何算法可判定。NP-hard 应对：近似（误差界限）或启发式（概率保证）；不可判定应对：寻找可判定的受限版本。
->
-> 循环不变量：每次迭代前后成立的性质，加终止条件蕴含输出正确。Hoare 逻辑：{P} S {Q}——前置条件 P 经语句 S 产生后置条件 Q。
-
-## GPU 友好性 / GPU-Friendliness（横切检查）
-
-算法思想是与 GPU 最直接相关的武器——复杂度阶、并行度、访存/通信、算子融合直接决定一个算法能否在 GPU 上高效跑起来。每个算法须过 `../../references/gpu-friendly-math.md` 八维门：
-
-- **复杂度阶**：亚二次 O(n log n)/O(n) 友好（吃满并行核）；O(n²) 边界（GEMM 例外，Tensor Core 可救）；O(2^n)/O(n!) 反模式。
-- **并行与通信**：分治/数据并行友好（子问题独立、可批量）；动规的依赖链、回溯的串行搜索需改造（分块/斜扫描）。
-- **显存与 KV-Cache / 并行与通信**：coalesced 访问友好；butterfly 归约、前缀扫描的依赖需注意带宽；随机 scatter/gather 不友好。
-- **算子融合**：多步 elementwise 可融合为单 kernel；反复读写显存的"美丽但不可算"算法应重排为一次过。
-
-八维最低判定（正式术语）：**张量化**要求主循环可批量化；**GEMM 可映射**优先把核心计算写成 GEMM/conv/scan；**复杂度**必须给时间与空间阶；**显存与 KV-Cache**检查中间表、状态、缓存是否可分块；**低精度稳定**检查归约、排序、迭代误差；**并行与通信**检查依赖图与跨设备同步；**稀疏结构**只接受结构化稀疏；**算子融合**要求减少小 kernel 与往返显存。
-
-| 算法特征 | GPU 分类 | 说明 |
-|---|---|---|
-| 分治/归并/FFT | 友好 | 亚二次、可批量、结构规则 |
-| 动规（依赖链） | 可改造 | 分块/斜扫描打破串行依赖 |
-| 回溯/DFS 串行搜索 | 反模式 | 分支不可预测、无法填满 SIMD |
-| 蛮力 O(2^n) | 反模式 | 复杂度阶本身不可算 |
-
-> 配合 `../../references/books/matrix-analysis.md`（GEMM/低秩分解降阶）、`../../references/books/optimization-ml.md`（一阶/二阶法可行性）、`../../references/books/abstract-algebra.md`（半环/有限域上的并行算法）。
-
-## 不适用场景 / When NOT to Use
-
-- **问题有闭式解，不需要逐步计算**——如二次方程求根公式直接给答案，算法化反增复杂度。
-- **问题本质是定性的而非程序性的**——如"这个结构是否优美""这个证明是否有洞察力"无法化为有限步骤。
-- **输入无结构、无法离散化**——如连续感知数据流无法直接作为算法输入；预处理比核心问题更复杂时算法化未必最优。
-
-## 何时使用 / When to Use
-
-- 需要自动化重复过程——同一操作对大量数据反复执行，手动不可扩展。
-- 需要验证程序终止——证明算法在有限步内停机，是可靠性的基石。
-- 需要估算计算代价——大规模运行前评估时间/空间消耗，避免资源耗尽。
-- 面对组合爆炸——搜索空间随输入指数增长，需剪枝策略。
-- 需要判断问题可行性——确定 P / NP-hard / 不可判定，决定求解策略。
-- 需要设计高效求解步骤——从蛮力到精巧算法，效率差异可达数个量级。
-- **为 GPU 设计可执行算法/算子**——评估复杂度阶、并行度、访存与融合，使算法在硬件上真正可算。
-
-## 方法流程 / Method
-
-### 第一步：形式化输入输出规格 / Formalize I/O Spec
-定义输入域、输出域、约束条件。输入规格明确数据类型（整数/浮点/字符串/图）、规模范围 n∈[1,10^6]、合法性条件（前置条件）；输出规格明确返回类型、精度、边界处理；约束覆盖时间/空间限制与正确性保证（后置条件）。检验：若写不出前置/后置条件谓词，则规格尚未足够形式化。
-
-### 第二步：分解子问题 / Decompose into Sub-problems
-将大问题拆为可独立求解的小块，子问题边界清晰、接口明确。分解策略：按数据（处理不同子集）、按功能（完成不同子任务）、按层次（先粗后细逐层精化）。好的分解使每个子问题可独立验证，整体可递归验证；子问题间依赖须显式标注，避免隐式耦合。
-
-### 第三步：设计程序 / Design the Procedure
-选择算法范式——核心决策，选错则后续努力白费：
-
-- **分治 (Divide-and-Conquer)**：分割、求解子部分、合并。子问题独立、合并代价低于整体。经典：归并/快速排序、Strassen 矩阵乘。递推 T(n)=aT(n/b)+f(n) 由主定理求解。
-- **动态规划 (DP)**：重叠子问题、备忘录化避免重复。最优子结构成立。经典：最短路、背包、序列对齐。
-- **贪心 (Greedy)**：每步局部最优，期望全局。贪心选择性质成立。经典：Dijkstra、Huffman、MST。
-- **回溯 (Backtracking)**：系统性搜索、遇死路剪枝回退。搜索空间有结构。经典：N 皇后、TSP 精确解、CSP。
-- **随机化 (Randomized)**：概率捷径，以随机换效率。确定性代价过高。经典：随机快排、Monte Carlo、Las Vegas。
-
-选择原则：独立→分治、重叠→动规、贪心性质→贪心、结构化搜索→回溯、确定性代价过高→随机化。实际问题常混合多种范式。
-
-### 第四步：分析复杂度 / Analyze Complexity
-时间 O(f(n))、空间 O(g(n))，区分最坏与平均。识别基本操作计数、求解递推（主定理）、关注输入分布对平均复杂度的影响；除 O（上界）外关注 Ω（下界）与 Θ（精确界）。复杂度分析是设计中的持续评估，非事后验证。实际意义：n=10^6 时 O(n)≈10^6 步（秒级），O(n²)≈10^12 步（不可行），O(2^n) 远超宇宙年龄。
-
-### 第五步：证明正确性 / Prove Correctness
-使用循环不变量、结构归纳、终止证明、前置/后置条件。未经证明的算法是猜测。循环不变量：初始化（循环前成立）、维护（每次迭代保持）、终止（不变量加终止条件给后置条件）；结构归纳：假设子调用正确证当前调用；终止：构造递减度量证其严格递减；Hoare 逻辑：{P} S {Q}。
-
-### 第六步：检查可行性 / Check Tractability
-问题属 P？NP-hard？不可判定？P → 追求最优精确算法；NP-hard → 近似/启发式，明确误差界限或概率保证；不可判定 → 寻找可判定的受限版本。常见 NP-hard：TSP、图着色、子集和、SAT；常见不可判定：停机问题、希尔伯特第十问题。
-
-### 第七步：优化与改进 / Optimize and Improve
-减少常数因子、利用数据结构、并行化，基于瓶颈分析而非盲目调参。优化层次：(1) 算法级——换更优范式（O(n²)→O(n log n) 收益最大）；(2) 数据结构级——换更优存储/查询；(3) 实现级——缓存、并行、SIMD、算子融合；(4) 问题级——换表述使更易求解（可能质的飞跃）。优先级：算法级 > 数据结构级 > 实现级，问题级可能跃迁。每次优化后重新验证正确性。
-
-## 常见错误 / Common Errors
-
-| 错误 / Error | 批评 / Critique | 正确做法 / Correct Approach |
-|---|---|---|
-| 假设指数算法可接受 | NP-hard 对大 n 需启发式而非精确；2^50 步即使每步 1ns 需 35 年 | 对大 n 用近似/启发式，明确误差界限 |
-| 未证明终止性 | 无限循环是真实风险，挂起远比慢结果危险 | 用递减度量证终止，构造良序集上递减函数 |
-| 混淆最坏与平均情况 | 快排最坏 O(n²) 但平均 O(n log n)，最坏可能在实中出现 | 明确分析场景，注明假设 |
-| 混淆存在性与可构造性 | 解可能存在但不可计算；存在性≠可构造性 | 区分存在性证明与算法构造 |
-| 低估常数因子 | 巨大常数的 O(n log n) 可能比小常数 O(n²) 慢 | 实测比较，关注常数与缓存效应 |
-| 忽略空间复杂度 | 时间高效的算法可能爆内存；DFS 需 O(n) 但 BFS 需 O(2^n) | 同时分析时间与空间 |
-| 过早优化 | 未证正确就优化，方向可能全错 | 先证正确→析复杂度→再优化 |
-| 忽视输入分布 | 平均复杂度依赖分布假设，随机输入≠实际输入 | 标明分布假设，分析实际场景 |
-| 串行/不可融合算法上 GPU | 分支不可预测、依赖链串行、反复读写显存——"美但不可算" | 改造为并行/可融合/亚二次，过 GPU 八维门 |
-
-## 操作规程 / Operating Procedure
-
-当本 skill 被触发时，输出必须包含：
-
-1. **输入规格**：`[输入]: [描述]` — 例如：`[输入]: 无序整数数组 A[1..n]，n∈[1,10^6]`
-2. **输出规格**：`[输出]: [描述]` — 例如：`[输出]: A 的升序排列`
-3. **算法范式**：`[范式]: [分治/动规/贪心/回溯/随机化] 因为 [理由]`
-4. **复杂度**：`[时间]: O([f(n)]) [空间]: O([g(n)]) [场景]: [最坏/平均]`
-5. **正确性**：`[循环不变量/归纳策略]: [内容] ✅ 已证 / ❌ 未证`
-6. **可行性**：`[类别]: [P/NP-hard/不可判定] [应对]: [精确/近似/启发式/重新表述]`
-7. **改进建议**：`[优化方向]: [具体建议]`
-8. **[GPU 可行性]**（若用于算法/算子设计）— 复杂度阶/并行度/访存/融合评估，标注友好/可改造/反模式 + 改造建议
-
-**输出不得只给分析而无结论。**
-
-## 与其他 skill 的关系 / Relations to Other Skills
-
-- **优化思想**：梯度下降、分支定界等优化算法是算法思想的实例——优化关注最优值，算法关注达到最优值的步骤与代价。
-- **变换思想**：FFT 是算法思想应用于变换的典范——O(n²)→O(n log n)；变换把问题映到易解空间，算法在变换空间高效求解。
-- **逻辑演绎**：正确性证明使用演绎推理（循环不变量、归纳）——算法正确性证明本质是一串演绎步骤。
-- **归纳与类比**：分治用结构类比——子问题与原问题同构——正是归纳思想的算法化。
-- **离散/组合思想**：算法处理离散对象，组合计数支撑复杂度分析——组合爆炸是算法思维要克服的核心障碍。
-- **现代数学激活**：`../../references/books/matrix-analysis.md`（GEMM/低秩分解降阶）、`../../references/books/optimization-ml.md`（一阶/二阶法 GPU 可行性）、`../../references/books/abstract-algebra.md`（半环/有限域上的并行算法）。