math-skill 1.0.0 → 2.1.0

package/skills/game-theory/original-texts.en.md

@@ -0,0 +1,131 @@
+# Mathematical Sources and Classic Texts
+
+## Zermelo's Theorem (1913)
+
+> Zermelo (1913) proved: in any finite two-player game of perfect information (such as chess), either the first player or the second player has a winning strategy, or both players have a drawing strategy. That is, the game is "determined."
+
+**Core thesis**: For any finite game of perfect information, $\exists$ a winning strategy for the first player $\lor$ $\exists$ a winning strategy for the second player $\lor$ $\exists$ a drawing strategy for both. This proves that no genuine "uncertainty" exists in such games — the source of uncertainty is computational complexity rather than logical structure.
+
+**Key ideas**: The outcome of a perfect-information game is logically predetermined — uncertainty arises from limitations in computational power, not from the game itself. Zermelo's proof employed backward induction, which later became the central tool for subgame perfect equilibrium. Mathematical context: in the same year, Zermelo also introduced the Axiom of Choice (AC) in set theory. Game theory and set theory share the logic that "finite choices can always be exhaustively enumerated."
+
+## von Neumann's Minimax Theorem (1928)
+
+> von Neumann (1928) proved: in a two-player zero-sum game, $\max_{x \in \Delta} \min_{y \in \Delta} \sum_{ij} a_{ij} x_i y_j = \min_{y \in \Delta} \max_{x \in \Delta} \sum_{ij} a_{ij} x_i y_j$. That is, the optimal outcome under a conservative strategy equals the optimal outcome under the opponent's conservative strategy — max-min = min-max.
+
+**Core theorem**: For any two-player zero-sum matrix game $A$, there exist mixed strategies $x^*$ and $y^*$ such that
+
+$$v^* = \max_x \min_y x^\top A y = \min_y \max_x x^\top A y$$
+
+$v^*$ is called the value of the game. The proof utilizes the convex set separation theorem (which later revealed deep connections with the Brouwer fixed-point theorem).
+
+**Key ideas**: The minimax theorem reveals the structural symmetry of zero-sum games — "my maximizing my gain" is equivalent to "the opponent minimizing my gain." The optimal mixed strategy renders the opponent indifferent among all pure strategies. This theorem foreshadowed the duality of linear programming: Dantzig (1947) discovered that LP duality is equivalent to minimax, and von Neumann independently found the same connection.
+
+## Existence of Nash Equilibrium (1950)
+
+> Nash (1950) proved: every finite game (any number of players, non-zero-sum) has at least one mixed-strategy Nash equilibrium. The proof uses the Brouwer fixed-point theorem — constructing a best-response mapping $BR: \Delta \to \Delta$ whose fixed point is a Nash equilibrium.
+
+**Core theorem**: For any finite game $(N, \{S_i\}, \{u_i\})$, $\exists \sigma^* \in \Delta_1 \times \cdots \times \Delta_n$ such that for all $i$ and $s_i \in S_i$,
+
+$$u_i(\sigma^*) \geq u_i(s_i, \sigma^*_{-i})$$
+
+Nash's proof applies the Brouwer fixed-point theorem to the best-response mapping: $F(\sigma) = (BR_1(\sigma_{-1}), \ldots, BR_n(\sigma_{-n}))$, where the fixed point of $F$ is an equilibrium. Subsequent proofs also use the Kakutani fixed-point theorem (for set-valued correspondences).
+
+**Key ideas**: The existence of Nash equilibrium does not depend on the "goodwill" or "cooperative intent" of the players — it is a logical necessity of self-interested behavior in strategic interaction. The Nash equilibrium generalizes the minimax theorem from zero-sum games to non-zero-sum games, and from two-player adversarial settings to multi-player interaction. Mathematical context: the Brouwer fixed-point theorem (1911) is a central result in topology — every continuous map has a fixed point — and game theory and topology converge here.
+
+## Prisoner's Dilemma
+
+> The Prisoner's Dilemma is the most classic example in game theory: two players each have "cooperate" and "defect" strategies. Defection is the dominant strategy, yet (Defect, Defect) is Pareto-dominated by (Cooperate, Cooperate) — individual rationality leads to collective irrationalality.
+
+**Payoff matrix**:
+
+| | Cooperate (C) | Defect (D) |
+|---|---|---|
+| Cooperate (C) | (3, 3) | (0, 5) |
+| Defect (D) | (5, 0) | (1, 1) |
+
+Strictly dominant strategy analysis: for each player, defection strictly dominates cooperation ($5 > 3$ and $1 > 0$). The unique Nash equilibrium (D, D) yields payoff (1, 1), which is Pareto-dominated by (C, C) with payoff (3, 3).
+
+**Key ideas**: The Prisoner's Dilemma reveals the fundamental tension between individual and collective rationality — Nash equilibrium does not guarantee Pareto optimality. This dilemma is ubiquitous in reality: arms races, the tragedy of the commons, price wars, carbon emissions. Axelrod (1984) showed through computer tournaments that in the iterated Prisoner's Dilemma, the "Tit-for-Tat" strategy can sustain cooperation — repeated interaction changes the equilibrium structure.
+
+## Backward Induction & Subgame Perfection
+
+> Backward induction is the central analytical tool for sequential games: starting from terminal nodes and working backward, choosing the optimal action at each step. Selten (1965) defined the subgame perfect equilibrium (SPE): a strategy profile that constitutes a Nash equilibrium in every subgame — eliminating equilibria based on non-credible threats.
+
+**Core concept**: Nash equilibrium permits "non-credible threats" — a player claims they will take a certain action, but when that node is reached, deviation is more profitable. SPE requires the equilibrium to hold in every subgame, thereby eliminating non-credible threats. Backward induction is the standard method for computing SPE.
+
+**Key ideas**: In sequential games, the temporal structure introduces commitment and credibility issues — a "threat" must be rational to be effective. Backward induction decomposes multi-stage decisions into single-stage subproblems, in the spirit of Bellman's principle of optimality. Mathematical context: Zermelo's (1913) theorem used backward induction, and Selten (1965) systematized it into the SPE concept. Selten shared the 1994 Nobel Prize in Economics with Nash and Harsanyi.
+
+## Shapley Value & Cooperative Game Theory (1953)
+
+> Shapley (1953) proposed the unique allocation rule in cooperative games satisfying efficiency, symmetry, dummy player, and additivity — the Shapley value $\phi_i(v)$. It allocates coalition payoffs according to average marginal contributions.
+
+$$\phi_i(v) = \sum_{S \subseteq N \setminus \{i\}} \frac{|S|!(n - |S| - 1)!}{n!} [v(S \cup \{i\}) - v(S)]$$
+
+The Shapley value is the unique allocation satisfying the following four axioms:
+1. **Efficiency**: $\sum_i \phi_i(v) = v(N)$
+2. **Symmetry**: if $i$ and $j$ contribute equally in all coalitions, then $\phi_i = \phi_j$
+3. **Dummy player**: if $i$ contributes zero marginal value to every coalition, then $\phi_i = 0$
+4. **Additivity**: $\phi_i(v + w) = \phi_i(v) + \phi_i(w)$
+
+**Key ideas**: The Shapley value translates "fairness" into mathematical axioms — fairness is not subjective judgment but logical necessity. The central question of cooperative game theory: how should the total payoff generated by a coalition be distributed? The Shapley value provides the unique axiomatically justified answer. The core is another solution concept — no coalition receives less than its standalone value — but the core may be empty.
+
+## Nash Bargaining Solution (1950)
+
+> Nash (1950) proposed the unique bargaining solution satisfying Pareto optimality, symmetry, scale invariance, and independence of irrelevant alternatives. Given a disagreement point $d = (d_1, d_2)$ and a feasible set $S \subseteq \mathbb{R}^2$, the Nash solution maximizes $(u_1 - d_1)(u_2 - d_2)$.
+
+$$\max_{(u_1, u_2) \in S, u_i \geq d_i} (u_1 - d_1)(u_2 - d_2)$$
+
+Nash proved that this solution is the unique allocation satisfying the four axioms. The disagreement point $d$ is each party's payoff when negotiations break down — the more favorable the disagreement point, the more favorable the bargaining outcome.
+
+**Key ideas**: The bargaining problem translates "negotiation" into mathematical optimization — maximizing joint surplus subject to the feasible set and disagreement point constraints. The symmetry and Pareto optimality of the Nash solution make it a natural benchmark for fair negotiation. Mathematical context: this model connects cooperative and non-cooperative game theory — the Nash program asserts that all cooperative game solutions should be derived through non-cooperative game models.
+
+## Evolutionary Game Theory (Maynard Smith, 1973)
+
+> Maynard Smith (1973) proposed the Evolutionarily Stable Strategy (ESS): a strategy $\sigma^*$ is an ESS if for any invading strategy $\sigma \neq \sigma^*$, either $u(\sigma^*, \sigma^*) > u(\sigma, \sigma^*)$, or $u(\sigma^*, \sigma^*) = u(\sigma, \sigma^*)$ and $u(\sigma^*, \sigma) > u(\sigma, \sigma)$.
+
+**Core definition**: ESS is a stronger stability concept than Nash equilibrium — it requires not only "no incentive to deviate" but also "resistance to invasion." Nash equilibrium is a necessary condition for ESS, but ESS adds a stability requirement.
+
+**Key ideas**: Evolutionary game theory extends game theory from "rational choice" to "adaptive dynamics" — players need not be rational, they only need to adjust strategies through repeated interaction. Biological applications: sex-ratio games, Hawk-Dove games, resource competition. Economic applications: formation of market conventions, diffusion of technology standards. Mathematical context: ESS is connected to replicator dynamics — an ESS is a locally stable fixed point of the replicator dynamics.
+
+## Vickrey Auction & Auction Theory (1961)
+
+> Vickrey (1961) proposed the second-price sealed-bid auction: the highest bidder wins but pays the second-highest bid. Bidding one's true valuation is a dominant strategy — a foundational work in mechanism design.
+
+**Core theorem**: In a Vickrey auction, bidding one's true valuation $b_i = v_i$ is a weakly dominant strategy for every bidder. Proof: let $v_i$ be the true valuation and $p$ the second-highest bid. If $v_i > p$, bidding $b_i = v_i$ wins with payoff $v_i - p > 0$; if $b_i > v_i > p$, one still wins with the same payoff; if $b_i < v_i$, one may forgo positive surplus. Hence truthful reporting is optimal.
+
+Vickrey proved that for symmetric risk-neutral bidders, the four standard auctions (English, Dutch, first-price sealed-bid, second-price sealed-bid) yield equal expected revenue — the **Revenue Equivalence Theorem**. Milgrom & Weber (1982) generalized this to affiliated values, finding that the English auction yields the highest revenue.
+
+**Key ideas**: The Vickrey auction is the paradigm of an incentive-compatible mechanism — through clever design of the payment rule, self-interested behavior automatically leads to efficient outcomes. Auction theory applies game theory to market design: how can rules be designed to guide rational agents toward optimal outcomes? Mathematical context: Vickrey shared the 1996 Nobel Prize in Economics.
+
+## Mechanism Design (Hurwicz, Myerson, Maskin — Nobel 2007)
+
+> Mechanism design is the "reverse engineering" of game theory — given a desired outcome, design the rules of the game so that rational agents' self-interested behavior automatically achieves that goal. Hurwicz, Myerson, and Maskin received the 2007 Nobel Prize in Economics for this work.
+
+**Core concepts**:
+- **Incentive Compatibility**: truthful type reporting is an equilibrium strategy — agents have no incentive to misreport
+- **Revelation Principle**: any equilibrium of a Bayesian game can be implemented by a direct mechanism — agents truthfully report types in equilibrium, eliminating the need for complex strategies
+- **Myerson's optimal auction**: under the independent private values model, the mechanism maximizing the seller's expected revenue allocates to the bidder with the highest virtual valuation $v_i - (1 - F_i(v_i))/f_i(v_i)$
+
+$$\text{Virtual valuation: } \varphi_i(v_i) = v_i - \frac{1 - F_i(v_i)}{f_i(v_i)}$$
+
+- **Maskin Monotonicity**: a necessary condition for a social choice function to be Nash-implementable — monotonicity of preferences
+
+**Key ideas**: Mechanism design answers "how to design the rules" rather than "how to act under given rules" — working backward from the desired outcome to the structure of the game. The revelation principle simplifies mechanism design: one need only consider direct mechanisms. Incentive compatibility ensures alignment between rules and incentives — institutional design is not wishful thinking but mathematically verifiable engineering. Mathematical context: Hurwicz (1960s) introduced the concept of incentive compatibility; Myerson (1981) developed optimal auction theory; Maskin (1977/1999) developed Nash implementability theory.
+
+## Signaling Games (Spence, 1973)
+
+> Spence (1973) proposed the signaling model: under asymmetric information, a sender with private information communicates information to a receiver through observable actions (signals). Classic application: education as a signal of ability — high-ability individuals face lower costs of acquiring education, so educational investment conveys information about ability.
+
+**Core model**: The sender has type $t \in \{H, L\}$ (high/low ability), chooses signal $s \in \{e, 0\}$ (educated/uneducated), and the receiver observes $s$ and then chooses response $a$. Separating equilibrium: $H$ chooses $e$, $L$ chooses $0$ — the signal perfectly reveals type. Pooling equilibrium: both types choose the same signal — the signal carries no information.
+
+**Key ideas**: Signaling games reveal the economics of information transmission — signals must have differential costs to convey information (otherwise everyone would imitate). In the Spence model, the social value of education may be entirely signaling value rather than productivity enhancement — this sparked a profound discussion about the nature of education. Spence shared the 2001 Nobel Prize in Economics. Mathematical context: signaling games are a subclass of Bayesian games — type is private information, and strategies are type-dependent.
+
+## Repeated Games & Folk Theorem
+
+> Folk Theorem (informally circulated in the 1970s, systematized by Aumann 1981): in an infinitely repeated game, any individually rational payoff $v_i \geq \min_{s_{-i}} \max_{s_i} u_i(s_i, s_{-i})$ (the minimax payoff) can be sustained as the average payoff of a subgame perfect equilibrium.
+
+**Core theorem**: Let $v = (v_1, \ldots, v_n)$ be a feasible and individually rational payoff vector ($v_i \geq \underline{v}_i$, where $\underline{v}_i$ is $i$'s minimax value). Then, when the discount factor $\delta$ is sufficiently close to 1, $v$ can be realized as the average payoff of a subgame perfect equilibrium of the infinitely repeated game.
+
+Implementation mechanism: punishment strategy — a deviator is "punished" back to the minimax payoff level, so the short-term gain from deviation is offset by the long-term punishment.
+
+**Key ideas**: The Folk Theorem is the central result in repeated games — it explains why cooperation can be sustained in long-run interactions: the short-term gain from deviation is outweighed by the long-term loss from punishment. The theorem also explains why repeated games have infinitely many equilibria — virtually any feasible payoff can be realized. Aumann (2005 Nobel Prize) systematized this theory. Mathematical context: the discount factor $\delta$ approaching 1 makes future punishment sufficiently severe — $\delta \geq \frac{g}{g + l}$, where $g$ is the gain from deviation and $l$ is the punishment loss.

package/skills/induction-analogy/SKILL.en.md

@@ -0,0 +1,145 @@
+---
+name: induction-analogy
+description: |
+  Trigger when finding patterns from data/experience, specific→general, known→unknown, mathematical induction proofs (weak/strong/structural/transfinite), cross-domain analogical transfer of structures, or borrowing structures from other fields for algorithm/operator design.
+---
+
+# 📈 Induction & Analogy
+
+> "From the specific to the general, from the known to the unknown — induction discovers patterns, analogy transfers experience, but neither equals proof."
+>
+> — Pólya, *Mathematics and Plausible Reasoning*; Lakatos, *Proofs and Refutations*
+
+## Core Principle
+
+**Induction discovers general patterns from limited instances — the engine of new knowledge; analogy transfers understanding across domains. Neither is rigorous proof, but both are fundamental to discovering theorems, proposing hypotheses, and generating innovation. Rigor is a tool of verification, not of discovery — Pólya.**
+
+The distinction between induction and analogy: **Induction** moves from N specific cases → a general rule (vertical deepening); **analogy** moves from the structure of domain A → the structure of domain B (lateral transfer); both produce hypotheses rather than theorems and require subsequent verification.
+
+> **Mathematical Formalization**
+>
+> The critical distinction between inductive reasoning and inductive proof:
+> - Inductive reasoning: empirical, proposing hypotheses from observations
+> - Inductive proof: logical, mathematical induction is a rigorous deductive proof scheme
+> - Key: inductive reasoning generates conjectures; inductive proof verifies them — the two must not be conflated
+>
+> Variants of inductive proof and their applicable scenarios:
+> - **Weak Induction**: Prove P(1) holds + prove ∀k(P(k)→P(k+1)) → conclude ∀n P(n); applicable when P(k+1) depends only on P(k)
+> - **Strong / Complete Induction**: Assume P(1), P(2), …, P(k) all hold, prove P(k+1); applicable when P(k+1) depends on multiple predecessors
+> - **Structural Induction**: Prove P(base) holds + P(composite) follows from P(components); applicable to recursively defined structures (trees, lists, expressions)
+> - **Transfinite Induction**: For a well-ordered set (W, <), prove ∀α∈W(∀β<α P(β) → P(α)) → ∀α∈W P(α); applicable to well-ordered sets indexed beyond the natural numbers
+>
+> Formal description of Lakatos's methodology:
+> - **Monster-barring**: Treating a counterexample as an object outside the intended scope of the hypothesis and explicitly excluding it — the simplest form of revision, but one must guard against over-exclusion that renders the hypothesis vacuous
+> - **Lemma-incorporation**: Incorporating the hidden condition exposed by the counterexample into the hypothesis as a new lemma — makes the hypothesis more precise
+> - **Proof-strategy revision**: The counterexample reveals a fundamental flaw in the original proof approach, requiring a different proof framework — the most profound form of revision
+>
+> Structural similarity measure for analogies:
+> - Structural similarity = (number of successfully mapped relations + number of successfully mapped components) / (total source relations + total source components)
+> - High validity (homomorphism): most structures have correspondents, key relations are preserved
+> - Medium validity (partial homomorphism): some structures and relations are preserved, some are distorted
+> - Low validity (surface similarity): only appearance or terminology is similar; deep structures differ
+
+## GPU-Friendliness (Cross-Cutting Check)
+
+Induction and analogy are inherently **meta-heuristic** — they generate conjectures and transfer structures, but do not directly prescribe computations. What must actually pass the GPU eight-dimension gate is their **product**: the structure being transferred into algorithm/operator design. If the analogically transferred structure is intractable, it must be adapted.
+
+- **Friendly**: The transferred structure can be expressed as dense GEMM chains or low-rank linear maps — e.g., structural induction ideas mapped to fusable implementations of recursive operators, algebraic homomorphism analogies mapped to low-rank GEMM (dimensions 1/2/4).
+- **Adaptable**: Transferred global/serial structures (naive cohomology computations, unstructured graph traversals, naive RNN-style recurrence) → adapt via block sparsification, low-rank projection, or tropical semiring relaxation (see adaptation techniques in `../../references/gpu-friendly-math.md`).
+- **Anti-pattern**: Adopting a structure solely because it is isomorphic/homomorphic and elegant, while ignoring O(n²) memory, fp64 dependence, or long serial recurrences — "mathematical beauty ≠ tractability"; an analogical conclusion may be mathematically correct yet hardware-infeasible.
+
+Eight-dimension minimum criteria (formal terms): **Tensorization** checks batch-expressibility of the transferred structure; **GEMM-mappability** checks whether the core operator after analogy maps to matrix multiplication; **complexity** checks whether global constructions brought from the source domain explode; **memory and KV-cache** checks whether large tables or long caches are introduced; **low-precision stability** checks whether the analogical structure depends on exact symbolic or high-precision computation; **parallelism and communication** checks whether recurrences or interactions can be chunked; **sparse structure** checks whether sparsity is regular; **operator fusion** checks whether the transferred structure can be realized as a small number of fused ops.
+
+> Used together with `../../references/gpu-friendly-math.md` (eight-dimension gate), `../../references/books/abstract-algebra.md` (homomorphism/isomorphism structures), `../../references/books/algebraic-geometry-rising-sea.md` (cross-domain structure transfer and compression).
+
+## When NOT to Use
+
+- **Rigorous proof is required** — inductive reasoning and analogy can only produce hypotheses, not proofs; however, mathematical induction itself is a proof method.
+- **There is only one or very few samples** — inductive reasoning needs a sufficient number of instances for support.
+- **The two domains are too different** — analogy requires structural similarity, not mere surface resemblance.
+- **The conclusion must have zero error** — inductive reasoning carries uncertainty; analogy carries distortion risk.
+- **The problem can be solved directly by deduction** — there is no need to detour through induction.
+
+## When to Use
+
+- Multiple cases have been observed sharing a common pattern, and one wishes to propose a general hypothesis.
+- Attempting to discover new theorems or new regularities in research.
+- Properties of recursively defined structures (trees, lists, expressions) need to be proved — use structural induction.
+- Propositions involving decomposition (e.g., prime factorization of integers) need to be proved — use strong induction.
+- Arguments over well-ordered sets beyond the natural numbers are needed — use transfinite induction.
+- Cross-disciplinary borrowing — can methods from other fields be applied to one's own problem?
+- **Borrowing structures from other fields for algorithm/operator design** — cross-domain analogical transfer of structures (e.g., algebraic homomorphism → low-rank mapping, sheaf diffusion → block summary), passing the GPU eight-dimension gate before adoption.
+
+## Method
+
+### Step 1: Collect Concrete Cases
+Systematically collect and observe concrete instances: extract key cases from the literature, gather patterns from experimental data, and organize known theorems. Ensure cases cover boundary values, typical values, and extreme values. The diversity and coverage of cases determine the quality of induction — too few or too homogeneous cases will be misleading.
+
+### Step 2: Identify Patterns
+Compare commonalities and differences across cases: what features appear in all (or most) cases? What appears only in some? Are the differences themselves patterned? Be aware that patterns may suddenly break after a number of cases (as in the Borwein integral phenomenon) — focusing only on commonalities can cause one to miss counterexamples.
+
+### Step 3: Formulate a Hypothesis
+Based on the observed pattern, formulate a general hypothesis: **strong hypothesis** ∀n P(n) (holds in all cases); **weak hypothesis** P(n) holds for sufficiently large n (with exceptions); **conditional hypothesis** ∀n∈S P(n) (on a specific subset). Selection principle: try the strong hypothesis first, then weaken it stepwise with counterexamples. The hypothesis must be specific enough to be falsifiable.
+
+### Step 4: Search for Counterexamples
+Actively seek counterexamples that falsify the hypothesis — the hallmark distinguishing science from pseudoscience. If a counterexample is found, revise (weaken or add conditions); if none is found, the hypothesis stands provisionally. Pay special attention to boundary conditions, extreme values, and whether the pattern suddenly fails when parameters change.
+
+### Step 5: Attempt a Proof
+For mathematical hypotheses, attempt a rigorous proof; selecting the correct induction variant is key:
+
+- **Weak Induction**: Prove P(1) + ∀k(P(k)→P(k+1)) → ∀n P(n); applicable when P(k+1) depends only on P(k) (summation formulas, simple recurrences); example: 1+2+…+n = n(n+1)/2.
+- **Strong Induction**: Assume P(1)..P(k) all hold and prove P(k+1); applicable when P(k+1) depends on multiple predecessors (decomposition, partition propositions); example: every integer greater than 1 is a product of primes, Fibonacci properties. Key: when P(k+1) must invoke P(j) for j<k, strong induction is required.
+- **Structural Induction**: Prove P(base) + P(composite) follows from P(components); applicable to recursively defined structures (trees, lists, expressions, formulas, program semantics); example: the number of leaf nodes in a binary tree equals the number of internal nodes plus 1. It is the natural extension of mathematical induction to recursive structures.
+- **Transfinite Induction**: For a well-ordered set (W,<), prove ∀α∈W(∀β<α P(β)→P(α)) → ∀α∈W P(α); applicable to well-ordered sets indexed beyond the natural numbers (ordinals, partially ordered sets, topological transitive closures); example: applications of Zorn's lemma, recursive constructions in set theory.
+- **Well-ordering principle equivalence**: Every non-empty subset has a least element ↔ natural number induction ↔ strong induction ↔ transfinite induction on well-ordered sets. Practical implication: choose the most natural formulation.
+
+### Step 6: Analogical Transfer
+Using analogy requires quantitative evaluation rather than relying solely on intuition:
+
+- **Structural similarity measure**: Structural similarity = (number of successfully mapped relations + number of successfully mapped components) / (total source relations + total source components).
+- **Analogy validity grading**: **High validity (homomorphism)** — most structures have correspondents, key relations are preserved, conclusions have high credibility; **Medium validity (partial homomorphism)** — some are preserved and some are distorted, conclusions must be revised before use; **Low validity (surface similarity)** — only appearance/terminology is similar, deep structures differ, conclusions are essentially unreliable.
+- **Systematic verification checklist**: (i) Does every component in the source domain have a correspondent in the target domain? (ii) Does every relation hold in the target domain? (iii) Is every operation defined in the target domain? (iv) Mapping consistency: if a↦a', b↦b', does R(a,b) imply R'(a',b')?
+
+### Step 7: Hypothesis Revision
+Revise the hypothesis based on counterexamples and proof attempts, following Lakatos's methodology: **Monster-barring** — treating the counterexample as outside the intended scope and explicitly excluding it (simplest; guard against over-exclusion leading to vacuity); **Lemma-incorporation** — incorporating the hidden condition exposed by the counterexample as a new lemma (makes the hypothesis more precise); **Proof-strategy revision** — the counterexample reveals a fundamental flaw in the original proof approach, requiring a different proof framework (most profound). After revision, return to Step 4 and iterate until the hypothesis stabilizes.
+
+## Common Errors
+
+| Error | Critique | Correct Approach |
+|-------|----------|-----------------|
+| Induction from insufficient samples | "Patterns" induced from 2–3 cases are extremely unreliable | Sample size must be large enough and cover diverse cases |
+| Treating inductive reasoning as proof | Inductive reasoning only produces hypotheses, not proofs; mathematical induction is a proof method | Distinguish inductive reasoning from inductive proof: the former generates conjectures, the latter verifies them |
+| Confirmation bias | Only seeing cases that support the hypothesis while ignoring counterexamples | Actively search for counterexamples — the most critical step |
+| Surface analogy | Analogy based on surface similarity rather than structural similarity | The basis of analogy is structural isomorphism/homomorphism, not surface resemblance |
+| Overextending analogy | Two domains are not fully isomorphic; analogical conclusions are not fully valid | Quantitatively evaluate analogy strength using structural similarity |
+| Failing to verify after induction | Proposing a hypothesis without testing it | The hypothesis must be tested against counterexamples and/or proved |
+| Using weak induction when strong induction is needed | When P(k+1) depends on multiple predecessors, weak induction cannot complete the inductive step | Identify the dependency structure: if P(k+1) must invoke P(j) for j<k, use strong induction |
+| Evaluating analogy by surface features alone | Surface feature similarity does not imply structural similarity; conclusions may be entirely wrong | Use systematic mapping to compare components, relations, and operations one by one |
+| Conflating inductive reasoning with inductive proof | Inductive reasoning is empirical; inductive proof is deductive — they are fundamentally different in nature | Distinguish clearly: reasoning → hypothesis; proof → theorem |
+| Ignoring pattern disruption (Borwein integrals) | Patterns that hold for the first several cases may suddenly break down; inductive reasoning has blind spots | Check sufficiently many cases; watch for sudden pattern changes at boundaries and under parameter variations |
+| Transferring intractable structures via analogy | Adopting a structure solely because the isomorphism is elegant, while ignoring O(n²) memory or fp64 dependence — "mathematical beauty ≠ tractability" | Run the transferred structure through the GPU eight-dimension gate first; if intractable, adapt (low-rank / block-sparse / relaxation) before adoption |
+
+## Operating Procedure
+
+When this skill is triggered, the output must include:
+
+1. **Case inventory**: `[Case N]: [description] [key features]`, ensuring coverage of boundary and extreme values.
+2. **Pattern identification**: `[Common pattern]: [description] [frequency: N/M] [Difference pattern]: [description]`, noting whether Borwein-type sudden disruption occurs.
+3. **Hypothesis statement**: `[Hypothesis]: [content] [type: strong/weak/conditional]`, trying the strong hypothesis first.
+4. **Counterexample search**: `[Counterexample]: [found/not found]. If found: [description], hypothesis revision: [new statement]`.
+5. **Proof direction**: `[Induction type: weak/strong/structural/transfinite]` with a proof outline; explain why this variant was chosen.
+6. **Analogy mapping**: `[Source domain A] → [Target domain B]: [correspondence] [structural similarity: X/Y] [validity: high/medium/low]`, verifying components, relations, and operations item by item.
+7. **Hypothesis revision**: `[Revision method: monster-barring/lemma-incorporation/strategy revision] [Revised hypothesis]`.
+8. **[GPU feasibility]** (if the transferred structure is used for algorithm/operator design) — run the transferred structure through `../../references/gpu-friendly-math.md` eight-dimension gate, annotate as friendly / retrofittable / unfriendly + adaptation suggestions.
+
+**The output must not present analysis alone without a conclusion; when further execution is needed, state in one sentence at the end what will be done next.**
+
+## Relations to Other Skills
+
+- **Logical deduction**: Induction generates hypotheses; deduction proves them — the two wings of discovery and verification.
+- **Abstraction thinking**: Analogy is essentially identifying the common abstract structure of two domains.
+- **Probability and statistics**: The probabilistic version of inductive reasoning is statistical inference.
+- **Modeling thinking**: The inductive process of discovering patterns from data is also part of modeling.
+- **Algorithmic thinking**: Induction as a correctness proof paradigm — loop invariants are induction hypotheses, and the correctness of recursive programs relies on structural induction.
+- **Discrete / Combinatorial thinking**: Combinatorial induction — inductive arguments on combinatorial objects, such as graph-theoretic induction and inductive recurrences in generating function methods.
+- **Modern mathematics activation**: `../../references/books/abstract-algebra.md` (structural analogy: homomorphism/isomorphism as formalization of analogy), `../../references/books/algebraic-geometry-rising-sea.md` (cross-domain structure transfer: sheaves/restriction maps/Plücker compression).