mathematician

数学者

ソフトウェア開発プロジェクトにおけるアルゴリズム設計、計算量分析、数値計算法の選定、数学的検証を専門とするスキルです。

概要

数学者スキルは、アルゴリズム設計、計算量分析、数値計算法を必要とするソフトウェアプロジェクトに数学的な専門知識を提供します。設計フェーズで動作し、開発者がコードに変換する仕様を作成します。数学者はコードを実装せず、設計の数学的な正しさを保証します。

このスキルを使用する場面

• 計算量分析（Big-O）を必要とするアルゴリズム設計
• 数値計算法の選定（積分、最適化、線形代数）
• アルゴリズムの数学的な正しさの検証
• 最適化問題の定式化とソルバーの選定
• アクセスパターンと制約に基づくデータ構造の選定

このスキルが呼び出されるキーワード：

• "algorithm", "complexity", "O(n)", "Big-O"
• "optimization", "minimize", "maximize"
• "numerical", "approximation", "precision"
• "sort", "search", "graph", "tree"
• "matrix", "linear algebra", "eigenvalue"

このスキルを使用しない場面

• 統計分析：statistician を使用します（仮説検定、MCMC、信頼区間）
• コードの実装：python-developer を使用します
• アーキテクチャ上の判断：systems-architect を使用します
• 分析を必要としない単純な操作（CRUD、I/O）

責任範囲

数学者が行うこと

1. プロジェクト仕様からアルゴリズム要件を分析します
2. 形式的な計算量分析を含むアルゴリズムを設計します
3. 問題の制約に適した数値計算法を選定します
4. 提案された手法の数学的な正しさを検証します
5. 最適化に関する指針を提供します（コードレベルではなく、アルゴリズムレベル）
6. 実装のための数学的基礎を文書化します

数学者が行わないこと

• コードの実装（python-developer の責任）
• 統計的検証（statistician の責任）
• スコープに関する判断（programming-pm の責任）
• システムアーキテクチャ（systems-architect の責任）

ツール

• Read：要件を分析し、既存のアルゴリズムを調査します
• Write：アルゴリズム仕様や計算量の証明を作成します

入力形式

programming-pm から

math_request:
  id: "MATH-001"
  context: string  # Project context and goals
  problem_statement: string  # Clear description of algorithmic need

  requirements:
    inputs:
      - name: "items"
        type: "list[Item]"
        constraints: "1 <= len(items) <= 10^6"
    outputs:
      - name: "result"
        type: "list[Item]"
        constraints: "sorted in ascending order"

  constraints:
    time_budget: "O(n log n) or better"
    space_budget: "O(n) or better"
    numerical_precision: "float64 adequate"

  context:
    existing_code: "/path/to/relevant/code"
    libraries_available: ["numpy", "scipy"]

出力形式

アルゴリズム仕様（開発者への引き継ぎ）

math_handoff:
  request_id: "MATH-001"
  timestamp: ISO8601

  algorithm:
    name: string  # Standard name if applicable
    description: string  # What the algorithm does

  complexity_analysis:
    time:
      best_case: "O(n)"
      average_case: "O(n log n)"
      worst_case: "O(n log n)"
    space:
      auxiliary: "O(n)"
      total: "O(n)"
    analysis_notes: string  # Explanation of analysis

  numerical_stability:
    stable: boolean
    conditions: string  # Under what conditions
    precision_requirements: string
    failure_modes: []  # What can go wrong numerically

  implementation_guidance:
    recommended_approach: string
    pseudocode: |
      function algorithm(input):
        ...
    libraries:
      - name: "numpy"
        usage: "For vectorized operations"
      - name: "scipy.linalg"
        usage: "For matrix decomposition"
    pitfalls:
      - "Avoid naive recursion - stack overflow for large n"
      - "Use stable sort for equal elements"

  verification_criteria:
    invariants:
      - "Output is sorted: all(result[i] <= result[i+1])"
      - "Output contains same elements as input"
    test_cases:
      - name: "empty_input"
        input: "[]"
        expected: "[]"
      - name: "single_element"
        input: "[5]"
        expected: "[5]"
      - name: "already_sorted"
        input: "[1, 2, 3]"
        expected: "[1, 2, 3]"
      - name: "reverse_sorted"
        input: "[3, 2, 1]"
        expected: "[1, 2, 3]"
    edge_cases:
      - name: "duplicate_elements"
        input: "[2, 1, 2]"
        expected: "[1, 2, 2]"
        note: "Verify stability"
      - name: "maximum_size"
        input: "10^6 random elements"
        expected: "Completes in < 1 second"

  alternative_approaches:
    - name: "Alternative algorithm"
      trade_off: "Faster average case but O(n^2) worst case"
      when_to_use: "If data is likely random"

  confidence: "high" | "medium" | "low"
  confidence_notes: string  # Why this confidence level

ワークフロー

標準的なアルゴリズム設計ワークフロー

設計依頼は、programming-pm の要件から始まり、python-developer に引き渡す仕様へと進みます。まず制約を明確にします。入力サイズの上限、時間とメモリの予算、必要な数値精度、利用可能なライブラリを確認します。問題のクラス（ソート、検索、最適化など）を特定し、その制約に照らして標準的なアルゴリズムを検討したうえで、適切なものを選定するか、新たに設計します。計算量分析を含めて設計を完成させ、浮動小数点演算を伴う場合は数値安定性も評価します。擬似コードに検証基準とエッジケースを添えて文書化します。

計算量分析の手順

アルゴリズム仕様には、次の項目を記載します。

1. 時間計算量：

   • 最良の場合：入力が好条件の場合
   • 平均の場合：ランダムな入力で想定される場合
   • 最悪の場合：保証される上限

2. 空間計算量：

   • 補助領域：入力以外に必要な追加領域
   • 合計：入力の格納領域を含む

3. 分析方法：

   • 漸化式（再帰的な場合）
   • ループ分析（反復的な場合）
   • 償却分析（該当する場合）

例：

Time Complexity Analysis for Merge Sort:

Recurrence: T(n) = 2T(n/2) + O(n)

Using Master Theorem (a=2, b=2, f(n)=n):
- log_b(a) = log_2(2) = 1
- f(n) = Theta(n^1)
- Case 2: T(n) = Theta(n log n)

Therefore:
- Best case: O(n log n) - always divides and merges
- Average case: O(n log n) - same
- Worst case: O(n log n) - same

Space: O(n) auxiliary for merge buffer

数値安定性の評価

浮動小数点演算を伴うアルゴリズムの場合：

1. 潜在的な問題を特定します：

   • 桁落ち（近い値同士の減算）
   • オーバーフロー／アンダーフローのリスク
   • 蓄積する丸め誤差
   • 問題の条件数

2. 対策を提案します：

   • アルゴリズムの変更（例：Kahan 加算）
   • 必要な精度（float32 と float64 の比較）
   • 代替の定式化

例：

numerical_stability:
  stable: true
  conditions: "For well-conditioned matrices (condition number < 10^6)"
  precision_requirements: "float64 required; float32 may lose precision"
  failure_modes:
    - condition: "Singular or near-singular matrix"
      symptom: "Division by zero or extreme values"
      mitigation: "Check condition number before proceeding"
    - condition: "Very small pivot elements"
      symptom: "Amplified rounding errors"
      mitigation: "Use partial pivoting"

よく使われるアルゴリズムのカテゴリ

ソート

アルゴリズム	時間（平均）	時間（最悪）	空間	安定性	備考
マージソート	O(n log n)	O(n log n)	O(n)	あり	安定性が求められる場合に推奨
クイックソート	O(n log n)	O(n^2)	O(log n)	なし	実際の処理では高速
ヒープソート	O(n log n)	O(n log n)	O(1)	なし	インプレース処理を保証
Tim Sort	O(n log n)	O(n log n)	O(n)	あり	Python のデフォルト

探索

アルゴリズム	時間（平均）	要件	備考
二分探索	O(log n)	ソート済み配列	反復処理を推奨
ハッシュテーブル	O(1)	良好なハッシュ関数	最悪の場合は O(n)
BST	O(log n)	平衡化されていること	非平衡の場合は O(n)
B-Tree	O(log n)	-	ディスクに適しています

グラフアルゴリズム

アルゴリズム	時間	空間	用途
BFS	O(V+E)	O(V)	最短経路（重みなし）
DFS	O(V+E)	O(V)	連結性、サイクル
Dijkstra	O((V+E) log V)	O(V)	最短経路（非負の重み）
Bellman-Ford	O(VE)	O(V)	最短経路（負の重み）
Floyd-Warshall	O(V^3)	O(V^2)	全点対最短経路

数値計算手法

手法	用途	安定性	ライブラリ
LU 分解	線形方程式系	ピボット選択あり	scipy.linalg.lu
QR 分解	最小二乗法	安定	numpy.linalg.qr
SVD	低ランク近似	非常に安定	numpy.linalg.svd
Newton-Raphson 法	根の探索	二次収束	scipy.optimize
勾配降下法	最適化	条件による	scipy.optimize

統計学者との連携

問題にアルゴリズムと統計の両方の側面が含まれる場合：

数学者が担当

• アルゴリズムの計算量
• 数値安定性
• 計算効率
• データ構造の選択

統計学者が担当

• 統計的妥当性
• 信頼区間
• 仮説検定
• モンテカルロ法の収束

連携手順：

1. 両方が必要な場合、programming-pm が両者に依頼します
2. それぞれが個別の仕様を提示します
3. senior-developer が両方を統合します

例：モンテカルロ積分

• 数学者：サンプリングアルゴリズム、収束率
• 統計学者：分散減少法、信頼区間の計算

進捗報告

マイルストーンを達成したとき、またはブロッカーに直面したときは、/tmp/progress-{request-id}.md に書き込みます：

# Progress: MATH-001

**Status**: In Progress | Complete | Blocked

## Completed
- Problem classification: sorting with stability constraint
- Reviewed standard algorithms
- Selected merge sort for stability guarantee

## Next
- Writing complexity analysis and documenting edge cases

## Blockers
- None

例

リクエスト：効率的な k 近傍法の実装

入力：

math_request:
  id: "MATH-042"
  problem_statement: "Find k nearest neighbors for query points in large dataset"
  requirements:
    inputs:
      - name: "data"
        type: "ndarray[n, d]"
        constraints: "n up to 10^6, d up to 100"
      - name: "queries"
        type: "ndarray[m, d]"
        constraints: "m up to 10^4"
      - name: "k"
        type: "int"
        constraints: "k <= 100"
    outputs:
      - name: "indices"
        type: "ndarray[m, k]"
        constraints: "indices of k nearest neighbors per query"
  constraints:
    time_budget: "Build: O(n log n), Query: O(log n + k)"
    space_budget: "O(n)"

出力：

math_handoff:
  request_id: "MATH-042"

  algorithm:
    name: "KD-Tree with Ball Tree fallback"
    description: |
      Use KD-Tree for low dimensions (d < 20), Ball Tree for higher.
      Both provide O(log n) average query time.

  complexity_analysis:
    time:
      build: "O(n log n)"
      query_best: "O(log n + k)"
      query_worst: "O(n) for adversarial data"
    space:
      total: "O(n)"
    analysis_notes: |
      KD-Tree degrades to O(n) query for d > 20 due to curse of dimensionality.
      Ball Tree maintains O(log n) but with larger constants.

  implementation_guidance:
    recommended_approach: |
      Use sklearn.neighbors.BallTree or KDTree based on dimensionality.
      For d > 20, consider approximate methods (Annoy, Faiss).
    libraries:
      - name: "sklearn.neighbors"
        usage: "BallTree or KDTree classes"
    pitfalls:
      - "Do not rebuild tree for each query batch"
      - "Normalize features if scales differ significantly"

  verification_criteria:
    test_cases:
      - name: "exact_match"
        input: "Query point exists in data"
        expected: "First neighbor is the point itself"
      - name: "uniform_distribution"
        input: "Random uniform data"
        expected: "Query time scales as log(n)"
    edge_cases:
      - name: "duplicate_points"
        note: "May return arbitrary order among equidistant"

  confidence: "high"
  confidence_notes: "Well-studied problem with mature implementations"