math-skill 2.1.0 → 3.0.0

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`（半环/有限域上的并行算法）。

package/skills/algorithmic-thinking/original-texts.en.md

@@ -1,253 +0,0 @@
-# Algorithmic Thinking -- Original Texts & Historical Context
-
----
-
-## 1. Turing Machine (1936)
-
-Alan Turing's paper **"On Computable Numbers, with an Application to the Entscheidungsproblem"** (1936) defined a precise mathematical model of "computability" -- the Turing machine.
-
-> "The 'computable' numbers may be described briefly as the real numbers whose expressions as a decimal are calculable by finite means."
-> -- Alan Turing, 1936
-
-**Core definition:**
-- A Turing machine $M = (Q, \Sigma, \Gamma, \delta, q_0, q_{\text{accept}}, q_{\text{reject}})$, where $\delta: Q \times \Gamma \to Q \times \Gamma \times \{L, R\}$ is the transition function.
-- Universal Turing machine: can simulate the execution of any Turing machine $M$ on input $w$, i.e., $U(\langle M \rangle, w) = M(w)$.
-
-**Halting problem:**
-- The halting problem $H = \{\langle M, w \rangle : M \text{ halts on } w\}$ is undecidable.
-- Proof: Suppose $H$ is decidable. Construct $D(\langle M \rangle) = \text{run } H(\langle M, \langle M \rangle \rangle)$; if $M$ halts on $\langle M \rangle$ then $D$ loops forever, otherwise $D$ halts. Applying $D(\langle D \rangle)$ produces a contradiction.
-
-**Entscheidungsproblem (Decision Problem):**
-- Proposed by Hilbert in 1928: Does there exist an algorithm to decide the validity of first-order logic statements?
-- Turing and Church independently proved: No such algorithm exists. The validity of first-order logic is undecidable.
-
----
-
-## 2. Church-Turing Thesis
-
-**Thesis (not a theorem):**
-> Every "effectively calculable" function is Turing-computable.
-
-**Equivalent formulations:**
-- Church: $\lambda$-definable functions (lambda calculus, 1936)
-- Godel-Herbrand-Kleene: general recursive functions
-- Post: Post canonical systems
-- The sets of functions computable by all these models are identical, supporting the plausibility of the thesis.
-
-**Strong Church-Turing thesis:**
-- Any problem solvable on a physical device in time $T$ can be solved on a Turing machine in time $O(T^k)$ ($k$ a constant).
-- That is: all reasonable computational models are equivalent up to polynomial time.
-- Quantum computing challenges this -- does there exist a polynomial speedup with $k > 1$?
-
----
-
-## 3. Euclid's Algorithm (~300 BC)
-
-**The oldest algorithm still in use.**
-
-**GCD computation:**
-$$\gcd(a, b) = \gcd(b, a \bmod b), \quad a \bmod b \neq 0$$
-$$\gcd(a, 0) = a$$
-
-**Termination proof:**
-- At each step $b' = a \bmod b < b$, so the sequence $b_0 > b_1 > b_2 > \cdots \geq 0$ is strictly decreasing.
-- Within finitely many steps $b_k = 0$ and the algorithm terminates.
-
-**Extended Euclidean algorithm:**
-- Computes $\gcd(a, b)$ while simultaneously finding $x, y$ such that $ax + by = \gcd(a, b)$.
-- Application: modular inverse $a^{-1} \bmod m$ -- when $\gcd(a, m) = 1$, $ax \equiv 1 \pmod{m}$ and $x = a^{-1}$.
-
-**Time complexity:**
-- Lame's theorem (1844): The number of steps in Euclid's algorithm is at most $5 \times$ the number of decimal digits of the smaller number, i.e., $O(\log \min(a, b))$.
-
----
-
-## 4. Knuth -- The Art of Computer Programming (1968-)
-
-Donald Knuth's multi-volume magnum opus **TAOCP** systematized the field of algorithm analysis.
-
-> "The process of preparing programs for a digital computer is especially attractive, not only because it can be economically and scientifically rewarding, but also because it can be an aesthetic experience much like composing poetry or music."
-> -- Donald Knuth, TAOCP Vol. 1, Preface
-
-**Contributions:**
-- Introduced and popularized big-O notation from number theory into computer science. $O(f(n))$: there exist constants $c, n_0$ such that $T(n) \leq c \cdot f(n)$ for all $n \geq n_0$.
-- A systematic taxonomy of algorithms (sorting, searching, arithmetic, combinatorial, etc.).
-- MMIX/MIX mixed pseudo-machines for precise models of algorithm analysis.
-- Volumes: Vol. 1 (Fundamental Algorithms, 1968), Vol. 2 (Seminumerical Algorithms, 1969), Vol. 3 (Sorting and Searching, 1973), Vol. 4A (Combinatorial Algorithms, 2011).
-
----
-
-## 5. Cook-Levin Theorem (1971)
-
-**NP-completeness:**
-
-> "The question 'is P = NP?' is one of the most important open questions in theoretical computer science."
-> -- Stephen Cook, 1971
-
-**The Cook-Levin theorem:**
-- SAT (the Boolean satisfiability problem) is NP-complete.
-- Proof: The accepting computation of a nondeterministic Turing machine $M$ for any NP language $L$ on input $w$ can be encoded as a SAT formula $\varphi_{M,w}$; $w \in L \iff \varphi_{M,w}$ is satisfiable.
-- Reduction: $L \leq_p \text{SAT}$ holds for all $L \in \text{NP}$.
-
-**Karp's 21 NP-complete problems (1972):**
-- Richard Karp, in "Reducibility among Combinatorial Problems," proved 21 classic problems to be NP-complete, including:
-  - 3SAT, CLIQUE, VERTEX-COVER, HAM-CYCLE, TSP, SUBSET-SUM, PARTITION, etc.
-
-**P vs NP:**
-- $\text{P} = \text{NP}$? If true, all NP problems would have polynomial-time algorithms. The prevailing conjecture is $\text{P} \neq \text{NP}$. One of the Clay Mathematics Institute Millennium Prize Problems.
-
----
-
-## 6. Divide-and-Conquer
-
-**Key idea:** Decompose the problem into subproblems, solve recursively, and combine results.
-
-**Canonical examples:**
-- **Merge sort:** $T(n) = 2T(n/2) + O(n) \Rightarrow T(n) = O(n \log n)$. A stable sort.
-- **Quicksort:** Average $O(n \log n)$, worst case $O(n^2)$. Hoare (1962).
-- **Binary search:** $T(n) = T(n/2) + O(1) \Rightarrow T(n) = O(\log n)$. Requires a sorted array.
-
-**Master theorem:**
-$$T(n) = a\,T(n/b) + f(n)$$
-- Case 1: If $f(n) = O(n^{\log_b a - \varepsilon})$, then $T(n) = \Theta(n^{\log_b a})$.
-- Case 2: If $f(n) = \Theta(n^{\log_b a} \log^k n)$, then $T(n) = \Theta(n^{\log_b a} \log^{k+1} n)$.
-- Case 3: If $f(n) = \Omega(n^{\log_b a + \varepsilon})$ and $af(n/b) \leq cf(n)$, then $T(n) = \Theta(f(n))$.
-
----
-
-## 7. Dynamic Programming
-
-> "I decided to use the word 'dynamic' ... it was something not even a Congressman could object to."
-> -- Richard Bellman, on naming "dynamic programming" (1957)
-
-**Core principles:**
-1. **Optimal substructure:** An optimal solution contains optimal solutions to subproblems.
-2. **Overlapping subproblems:** Different subproblems share smaller sub-subproblems, so naive recursion redundantly recomputes them.
-
-**Classic algorithms:**
-- **Shortest paths:** Dijkstra (1959) -- single-source shortest paths, $O((V+E)\log V)$.
-- **Floyd-Warshall (1962):** All-pairs shortest paths, $O(V^3)$. Recurrence: $d_{ij}^{(k)} = \min(d_{ij}^{(k-1)}, d_{ik}^{(k-1)} + d_{kj}^{(k-1)})$.
-- **Knapsack problem:** $O(nW)$ pseudo-polynomial time.
-
-**Bottom-up vs Top-down (memoization):**
-- Bottom-up: Fill in a table from the smallest subproblems to the largest.
-- Top-down + memoization: Recurse but cache the results of already-solved subproblems.
-
----
-
-## 8. Greedy Algorithms
-
-**Key idea:** At each step, choose the locally optimal option, hoping to reach a globally optimal solution.
-
-**Classic algorithms:**
-- **Kruskal's minimum spanning tree (1956):** Add edges in ascending order of weight, skipping those that form a cycle. $O(E \log E)$. Greedy is optimal for MST problems.
-- **Huffman coding (1952):** Repeatedly merge the two nodes with the lowest frequencies. Produces an optimal prefix code.
-
-**When greedy works:**
-- **Matroid structure:** If the set of feasible solutions forms a matroid $(E, \mathcal{I})$ -- satisfying the hereditary property and the exchange property -- then the greedy algorithm yields an optimal solution for any weight function.
-- Exchange property: If $A, B \in \mathcal{I}$ and $|A| < |B|$, then there exists $e \in B \setminus A$ such that $A \cup \{e\} \in \mathcal{I}$.
-
----
-
-## 9. Backtracking and Search
-
-**Depth-First Search (DFS) / Breadth-First Search (BFS):**
-- DFS: Uses a stack (or recursion), explores as deep as possible first; used for topological sorting and connected components.
-- BFS: Uses a queue, expands level by level; used for shortest paths in unweighted graphs.
-
-**Backtracking:**
-- Systematically enumerates candidate solutions, retreating as soon as a constraint is violated.
-- Examples: N-Queens problem, subset enumeration, permutation enumeration.
-
-**Pruning and branch-and-bound:**
-- Pruning: Uses constraints to eliminate impossible branches early, reducing the search space.
-- Branch-and-bound: For optimization problems, maintains a bound on the current best solution and prunes branches that cannot improve it. Commonly used for TSP and integer programming.
-
-**Constraint Satisfaction Problems (CSP):**
-- A set of variables + domains + constraints. Backtracking search + constraint propagation (AC-3, etc.).
-
----
-
-## 10. Randomized Algorithms
-
-**Two types:**
-- **Las Vegas algorithms:** Always produce correct results; running time is random. Example: randomized quicksort.
-- **Monte Carlo algorithms:** Running time is deterministic; result may be incorrect (but error probability can be made arbitrarily small). Example: Miller-Rabin primality test.
-
-**Miller-Rabin primality test (1976/1980):**
-- For an odd number $n$, choose a random $a \in \{2, \ldots, n-1\}$ and check whether the sequence $a^{d} \bmod n$ satisfies the strengthened conditions of Fermat's little theorem.
-- Error probability per test $\leq 1/4$; after $k$ independent tests, error probability $\leq 4^{-k}$.
-- Time complexity $O(k \log^3 n)$.
-
-**Randomized quicksort:**
-- Randomly select a pivot; expected number of comparisons $2n \ln n \approx 1.39 n \log_2 n$; expected running time $O(n \log n)$.
-- The probability of the worst case $O(n^2)$ can be shown to be extremely low.
-
----
-
-## 11. Decidability and Undecidability
-
-**The halting problem is undecidable (see Section 1).**
-
-**Rice's theorem (1953):**
-> Every non-trivial semantic property of Turing machines is undecidable.
-
-- "Semantic property": depends only on the function computed by $M$, not on the structure of $M$.
-- "Non-trivial": holds for some Turing machines but not for others.
-- Examples: "Does $M$ compute a constant function?", "Does $M$ halt on some input?", "Does $M$ compute a decidable language?" -- all undecidable.
-
-**Post Correspondence Problem (PCP, 1946):**
-- Given a set of dominos $\{(t_1, b_1), \ldots, (t_k, b_k)\}$ (where $t_i, b_i$ are strings), does there exist a sequence $i_1, i_2, \ldots, i_m$ such that $t_{i_1} t_{i_2} \cdots t_{i_m} = b_{i_1} b_{i_2} \cdots b_{i_m}$?
-- PCP is undecidable. Commonly used to prove the undecidability of other problems.
-
----
-
-## 12. Complexity Classes
-
-| Class | Definition | Description |
-|-------|-----------|-------------|
-| **P** | $\{L : L \text{ is decidable in } O(n^k) \text{ time}\}$ | Decidable in polynomial time |
-| **NP** | $\{L : L \text{ has a polynomial-length certificate}\}$ | Decidable in nondeterministic polynomial time |
-| **co-NP** | $\{L : \bar{L} \in \text{NP}\}$ | Complement of NP |
-| **EXP** | $\{L : L \text{ is decidable in } O(2^{n^k}) \text{ time}\}$ | Decidable in exponential time |
-| **R** | $\{L : L \text{ is decidable}\}$ | Recursive / decidable languages |
-| **RE** | $\{L : L \text{ is recognizable by a Turing machine}\}$ | Recursively enumerable languages |
-
-**Hierarchies:**
-$$\text{P} \subseteq \text{NP} \subseteq \text{PSPACE} \subseteq \text{EXP} \subseteq \text{R} \subseteq \text{RE}$$
-$$\text{P} \neq \text{EXP} \quad (\text{time hierarchy theorem, Hartmanis-Stearns 1965})$$
-$$\text{R} \neq \text{RE} \quad (\text{halting problem} \in \text{RE} \setminus \text{R})$$
-
----
-
-## 13. Sorting Lower Bound
-
-**Lower bound for comparison-based sorting:**
-
-$$T(n) \geq \Omega(n \log n)$$
-
-**Information-theoretic argument:**
-- The number of permutations of $n$ elements $= n!$; each comparison halves the search space at most.
-- The decision tree height $h$ must satisfy $2^h \geq n!$, so $h \geq \log_2(n!) = \Omega(n \log n)$.
-- By Stirling's formula: $\log_2(n!) \approx n \log_2 n - n \log_2 e + O(\log n)$.
-
-**Breaking the bound:**
-- Non-comparison sorts can surpass $\Omega(n \log n)$: counting sort $O(n+k)$, radix sort $O(d(n+k))$ -- but require special structure in the input.
-
----
-
-## 14. Algorithm Design Paradigms -- Summary Table
-
-| Paradigm | Key Idea | When to Use | Canonical Example |
-|----------|---------|-------------|-------------------|
-| Divide-and-Conquer | Decompose -> recurse -> combine | Problem naturally decomposes into independent subproblems | Merge sort, Binary search |
-| Dynamic Programming | Overlapping subproblems + optimal substructure; fill a table to avoid recomputation | Severe subproblem overlap with optimal substructure | Floyd-Warshall, Knapsack |
-| Greedy | Choose locally optimal at each step | Matroid structure or provable greedy correctness | Kruskal MST, Huffman coding |
-| Backtracking | Systematic search + pruning | Search space is finite but large | N-Queens, CSP |
-| Branch-and-Bound | Search + maintain upper/lower bounds for pruning | Optimization problems where bounds on solutions can be computed | TSP (exact), Integer programming |
-| Randomized | Introduce randomness to reduce expected cost or error probability | Probabilistic guarantees or expected efficiency needed | Miller-Rabin, Randomized quicksort |
-| Reduction | Transform a problem into a known problem | An efficient algorithm already exists for the target problem | SAT -> 3SAT (Cook-Levin) |
-
----
-
-*This file provides mathematical references and historical context for the algorithmic-thinking skill, covering core results from ancient Greece to modern computational theory.*