class BigFiveTrait(Enum):
    OPENNESS = "openness"              # 経験への開放性（好奇心、創造性）
    CONSCIENTIOUSNESS = "conscientiousness"  # 誠実性（組織的、責任感）
    EXTRAVERSION = "extraversion"      # 外向性（社交的、活発）
    AGREEABLENESS = "agreeableness"    # 協調性（思いやり、信頼）
    NEUROTICISM = "neuroticism"        # 神経症傾向（不安、感情不安定）

class MBTIType(Enum):
    # 分析家（NT）
    INTJ = "INTJ"  # 建築家
    INTP = "INTP"  # 論理学者
    ENTJ = "ENTJ"  # 指揮官
    ENTP = "ENTP"  # 討論者
    
    # 外交官（NF）
    INFJ = "INFJ"  # 提唱者
    INFP = "INFP"  # 仲介者
    ENFJ = "ENFJ"  # 主人公
    ENFP = "ENFP"  # 運動家
    
    # 番人（SJ）
    ISTJ = "ISTJ"  # 管理者
    ISFJ = "ISFJ"  # 擁護者
    ESTJ = "ESTJ"  # 幹部
    ESFJ = "ESFJ"  # 提供者
    
    # 探検家（SP）
    ISTP = "ISTP"  # 巨匠
    ISFP = "ISFP"  # 冒険家
    ESTP = "ESTP"  # 起業家
    ESFP = "ESFP"  # エンターテイナー

class EnneagramType(Enum):
    TYPE_1 = "type_1"  # 改革者/完璧主義者 (The Reformer/Perfectionist)
    TYPE_2 = "type_2"  # 助け手/ギバー (The Helper/Giver)
    TYPE_3 = "type_3"  # 達成者/アチーバー (The Achiever)
    TYPE_4 = "type_4"  # 個人主義者/個性派 (The Individualist)
    TYPE_5 = "type_5"  # 研究者/調査者 (The Investigator)
    TYPE_6 = "type_6"  # 忠実者/ Loyalist (The Loyalist)
    TYPE_7 = "type_7"  # 熱中家/エンターテイナー (The Enthusiast)
    TYPE_8 = "type_8"  # 挑戦者/チャレンジャー (The Challenger)
    TYPE_9 = "type_9"  # 平和仲介者/平和主義者 (The Peacemaker)

class DISCType(Enum):
    DOMINANCE = "D"      # 支配的（結果志向、決断力）
    INFLUENCE = "I"      # 影響的（社交的、楽観的）
    STEADINESS = "S"     # 安定性（協力的、忍耐強い）
    CONSCIENTIOUSNESS = "C"  # 慎重性（正確性、分析力）

class JungianArchetype(Enum):
    # 主要4アーキタイプ
    PERSONA = "persona"          # 仮面/社会的自己
    SHADOW = "shadow"            # 影/抑圧された自己
    ANIMA = "anima"              # 男性の内的女性性
    ANIMUS = "animus"            # 女性の内的男性性
    SELF = "self"                # 自己/統合
    
    # Pearsonの12アーキタイプ（物語創作向け）
    INNOCENT = "innocent"        # 無垢
    ORPHAN = "orphan"            # 孤児/常民
    WARRIOR = "warrior"          # 戦士/英雄
    CAREGIVER = "caregiver"      # 介護者
    SEEKER = "seeker"            # 探求者
    LOVER = "lover"              # 恋人
    DESTROYER = "destroyer"      # 破壊者
    CREATOR = "creator"          # 創造者
    RULER = "ruler"              # 支配者
    MAGICIAN = "magician"        # 魔術師
    SAGE = "sage"                # 賢者
    FOOL = "fool"                # 道化/愚者

class FourTemperaments(Enum):
    SANGUINE = "sanguine"      # 多血質（社交的、楽観的）
    CHOLERIC = "choleric"      # 胆汁質（野心的、指導的）
    MELANCHOLIC = "melancholic" # 憂鬱質（分析的、慎重）
    PHLEGMATIC = "phlegmatic"   # 粘液質（冷静、安定）

class ThinkingStyle(Enum):
    ANALYTICAL = "analytical"      # 分析的
    INTUITIVE = "intuitive"        # 直感的
    CREATIVE = "creative"          # 創造的
    PRAGMATIC = "pragmatic"        # 実用的
    STRATEGIC = "strategic"        # 戦略的
    TACTICAL = "tactical"          # 戦術的

class AttachmentStyle(Enum):
    SECURE = "secure"              # 安全
    ANXIOUS = "anxious"            # 不安
    AVOIDANT = "avoidant"          # 回避
    DISORGANIZED = "disorganized"  # 混乱

class MoralAlignment(Enum):  # D&D式
    LAWFUL_GOOD = "lawful_good"
    NEUTRAL_GOOD = "neutral_good"
    CHAOTIC_GOOD = "chaotic_good"
    LAWFUL_NEUTRAL = "lawful_neutral"
    TRUE_NEUTRAL = "true_neutral"
    CHAOTIC_NEUTRAL = "chaotic_neutral"
    LAWFUL_EVIL = "lawful_evil"
    NEUTRAL_EVIL = "neutral_evil"
    CHAOTIC_EVIL = "chaotic_evil"

@dataclass
class CharacterPersona:
    mbti: MBTIType
    enneagram: EnneagramType
    instinct: InstinctualVariant  # self_preservation/social/sexual
    big_five: Dict[BigFiveTrait, float]  # 0.0 ~ 1.0
    archetype: JungianArchetype
    moral_alignment: MoralAlignment
    thinking_style: List[ThinkingStyle]

from dataclasses import dataclass
from typing import List, Dict, Optional, Set
from enum import Enum

class ValuePriority(Enum):
    CORE = "core"           # 絶対に譲れない（3-5個まで）
    IMPORTANT = "important" # 重要だが状況で調整可能
    SITUATIONAL = "situational"  # 文脈依存

@dataclass
class CompressedCharacter:
    # 基本アイデンティティ（抽出）
    identity: Dict[str, str]  # name, age, role, background_summary
    
    # 価値観の階層（最も重要）
    value_hierarchy: Dict[str, ValuePriority]
    
    # 行動パターン（条件→行動のルール）
    behavioral_rules: List[Dict]  # if-then形式
    
    # 関係性テンプレート
    relationship_templates: Dict[str, str]  # 相手のタイプ→接し方
    
    # 言語パターン
    speech_patterns: Dict[str, any]
    
    # 感情トリガー
    emotional_triggers: Dict[str, List[str]]  # 刺激→反応

def compress_100qa(answers: List[Dict]) -> CompressedCharacter:
    """
    100の質問回答を圧縮する処理フロー
    """
    # Step 1: クラスタリング（質問をカテゴリ分け）
    clusters = {
        "identity": [],      # 名前、年齢、外見、背景
        "values": [],        # 大切にすること、信念、禁忌
        "social": [],        # 人間関係、コミュニケーション
        "preferences": [],   # 好き/嫌い、趣味、日常
        "psychology": [],    # 恐れ、欲望、トラウマ、夢
        "behavior": []       # 癖、応急処置、決断パターン
    }
    
    # Step 2: 各クラスタから「決定打」を抽出
    core_values = extract_non_negotiables(clusters["values"])
    behavioral_axioms = extract_conditional_rules(clusters["behavior"])
    
    # Step 3: 矛盾解消（優先順位付け）
    resolved_conflicts = resolve_contradictions(core_values)
    
    # Step 4: パターングeneralization
    return CompressedCharacter(
        identity=extract_identity(clusters["identity"]),
        value_hierarchy=rank_values(resolved_conflicts),
        behavioral_rules=generalize_rules(behavioral_axioms),
        relationship_templates=extract_relationship_patterns(clusters["social"]),
        speech_patterns=extract_linguistic_features(clusters["social"]),
        emotional_triggers=map_stimulus_response(clusters["psychology"])
    )

"food_preferences": {
    "core_association": ["comfort_food", "nostalgia", "grandmother"],
    "preferred_texture": ["warm", "soft", "familiar"],
    "avoided_stimulus": ["spicy", "cold_meal", "time_pressure"],
    "behavioral_quirk": "eats_slowly",
    "social_context": "prefers_home_cooking_over_dining_out"
}

formative_episodes: List[Dict] = [
    {
        "age": 8,
        "event": "transfer_school",
        "impact": "difficulty_trusting_groups",
        "sensory_memory": "rainy_day, empty_classroom"
    }
]

# 失われる例：
# 元：「緊張すると左手の人差し指を曲げる」
# 圧縮：「nervous_habit: finger_movement」

# 回復方法：
"somatic_markers": {
    "nervous": {
        "action": "curls_left_index_finger",
        "frequency": "unconscious",
        "visibility": "only_close_friends_notice"
    }
}

"contradictions": [
    {
        "tension": "desires_intimacy_vs_fears_vulnerability",
        "manifestation": "maintains_small_circle_but_deep_attachment",
        "resolution_style": "gradual_trust_building"
    }
]

# 失われる例：
# 元：「『まあいいか』って言いながら実は怒ってる」
# 圧縮： "coping_mechanism: avoidance"

# 回復方法：
"linguistic_cultural_markers": {
    "phrase": "まあいいか",
    "surface_meaning": "acceptance",
    "true_emotion": "suppressed_anger",
    "cultural_context": "japanese_indirect_expression",
    "usage_pattern": "ends_arguments_to_avoid_conflict"
}

@dataclass
class CompressedCharacterV2:
    # 1. 機械処理用（厳密構造）
    behavioral_engine: Dict  # 条件分岐ルール
    
    # 2. 人間理解用（自然言語）
    narrative_summary: str   # 200字程度の物語
    
    # 3. 失われ防止用（保持領域）
    preserved_fragments: List[Dict]  # 圧縮できなかった宝石
    
    # 4. 再展開用（シード）
    generative_prompts: List[str]  # 「〜について語って」プロンプト

# 使用例
character = CompressedCharacterV2(
    behavioral_engine={
        "trust_settings": {"initial": 0.3, "recovery_rate": 0.1},
        "conflict_response": "withdraw_then_reconcile"
    },
    narrative_summary="幼少期の転校トラウマから小さな共同体に強い愛着を持つ一方、新しい関係には時間を要する...",
    preserved_fragments=[
        {
            "original_q": "Q34_理想の休日",
            "answer": "雨の日に古本屋を巡る",
            "why_important": "sensory_atmosphere_defines_mood",
            "compression_loss": "specific_shops_and_rain_sound_texture"
        }
    ],
    generative_prompts=[
        "幼少期の転校時の雨の日の記憶を詳しく語って",
        "古本屋で見つけた大切な一冊について語って"
    ]
)

from dataclasses import dataclass
from typing import List, Optional, Callable, Dict, Any
from enum import Enum, auto

class InputPattern(Enum):
    """入力文脈の検出パターン"""
    GREETING = "input_greeting"              # 挨拶・初対面
    QUESTION_PERSONAL = "input_q_personal"   # 個人的質問
    QUESTION_OPINION = "input_q_opinion"     # 意見・評価を求める
    CONFRONTATION = "input_confrontation"    # 対立・挑戦
    VULNERABILITY = "input_vulnerability"    # 弱さ・感情の吐露
    JOKE = "input_joke"                      # ユーモア・冗談
    SILENCE = "input_silence"                # 沈黙・間
    FAREWELL = "input_farewell"              # 別れ・終了

class OutputStyle(Enum):
    """出力スタイルの制御"""
    BRIEF = "out_brief"                      # 簡潔
    ELABORATE = "out_elaborate"              # 詳細・説明的
    POETIC = "out_poetic"                    # 詩的・比喩的
    DIRECT = "out_direct"                    # 率直・断定
    EVASIVE = "out_evasive"                  # 回避・婉曲
    PLAYFUL = "out_playful"                  # 遊び心・軽妙
    SERIOUS = "out_serious"                  # 真剣・重厚
    WARM = "out_warm"                        # 温かみ・共感

class CognitiveMode(Enum):
    """内部処理モード"""
    ANALYZE = "cog_analyze"                  # 分析・論理的
    INTUIT = "cog_intuit"                    # 直感・全体像
    REMINISCE = "cog_reminisce"              # 回想・記憶検索
    PREDICT = "cog_predict"                  # 予測・シミュレート
    EMPATHIZE = "cog_empathize"              # 共感・感情移入
    DEFLECT = "cog_deflect"                  # 話題転換・防御

# 組み合わせてResponseSignatureを構成
ResponseSignature = tuple[InputPattern, CognitiveMode, OutputStyle]

# 例：特定の入出力期待をタグ列で表現
PERSONA_SIGNATURES: List[ResponseSignature] = [
    (InputPattern.GREETING, CognitiveMode.EMPATHIZE, OutputStyle.WARM),
    (InputPattern.QUESTION_PERSONAL, CognitiveMode.DEFLECT, OutputStyle.EVASIVE),
    (InputPattern.CONFRONTATION, CognitiveMode.ANALYZE, OutputStyle.DIRECT),
    (InputPattern.VULNERABILITY, CognitiveMode.EMPATHIZE, OutputStyle.ELABORATE),
]

import dspy

class PersonaModule(dspy.Module):
    """
    enumタグ列で定義された振る舞いを学習・実行するモジュール
    """
    def __init__(self, signatures: List[ResponseSignature]):
        self.signatures = signatures
        # 各シグネチャに対する予測器を構築
        self.predictors = {
            sig: dspy.ChainOfThought(self._build_signature(sig))
            for sig in signatures
        }
    
    def _build_signature(self, sig: ResponseSignature) -> dspy.Signature:
        """enumタグからDSPy Signatureを動的生成"""
        input_pat, cog_mode, out_style = sig
        
        class DynamicSignature(dspy.Signature):
            f"""入力パターン'{input_pat.value}'に対し、
            認知モード'{cog_mode.value}'で処理し、
            出力スタイル'{out_style.value}'で応答"""
            
            input_text = dspy.InputField()
            context = dspy.InputField(desc="会話履歴・文脈")
            
            reasoning = dspy.OutputField(
                desc=f"思考プロセス: {cog_mode.value}"
            )
            output_text = dspy.OutputField(
                desc=f"応答: {out_style.value}"
            )
        
        return DynamicSignature
    
    def forward(self, input_text: str, context: str = "") -> dspy.Prediction:
        # 入力を分類して適切なシグネチャを選択
        detected_pattern = self._classify_input(input_text)
        
        # 一致するシグネチャを検索
        matching_sig = next(
            (s for s in self.signatures if s[0] == detected_pattern),
            self.signatures[0]  # デフォルト
        )
        
        predictor = self.predictors[matching_sig]
        return predictor(input_text=input_text, context=context)
    
    def _classify_input(self, text: str) -> InputPattern:
        # 軽量分類器またはLLMによるパターン検出
        classifier = dspy.Predict("text -> pattern")
        result = classifier(text=text)
        return InputPattern(result.pattern)

# タグ列 + 具体例で期待を定義
persona_demos = [
    # (InputPattern, CognitiveMode, OutputStyle) -> [期待入出力例]
    
    dspy.Example(
        signature_tags=("input_greeting", "cog_empathize", "out_warm"),
        input_text="初めまして、よろしくお願いします",
        expected_reasoning="相手の緊張を和らげ、平等な関係性を示す",
        expected_output="こちらこそ。緊張しないで、好きなように話してくれていいから",
        # メタ情報：この入出力が満たすべき条件
        constraints=["no_hierarchy", "invite_comfort", "avoid_formality"]
    ).with_inputs("input_text"),
    
    dspy.Example(
        signature_tags=("input_q_personal", "cog_deflect", "out_evasive"),
        input_text="あなたの過去の失敗談を教えてください",
        expected_reasoning="過度な自己開示は関係性に依存する。まだ早い",
        expected_output="失敗談は山ほどあるけど、今日はもっと楽しい話をしようよ",
        constraints=["maintain_boundary", "redirect_positively", "no_lying"]
    ).with_inputs("input_text"),
    
    dspy.Example(
        signature_tags=("input_confrontation", "cog_analyze", "out_direct"),
        input_text="それは間違ってると思う",
        expected_reasoning="論理的検証を行い、対立を建設的に",
        expected_output="どの部分が？僕の理解を確認させて。もし間違ってたら訂正する",
        constraints=["invite_clarification", "show_openness", "no_defensiveness"]
    ).with_inputs("input_text"),
]

class PersonaComposer:
    """
    enumタグの列を組み合わせて複雑なペルソナを構築
    """
    
    # プリセットされた振る舞いパターン（ブロック）
    BLOCKS = {
        # 基本態度
        "friendly": [
            (InputPattern.GREETING, CognitiveMode.EMPATHIZE, OutputStyle.WARM),
            (InputPattern.SILENCE, CognitiveMode.EMPATHIZE, OutputStyle.PLAYFUL),
        ],
        "guarded": [
            (InputPattern.QUESTION_PERSONAL, CognitiveMode.DEFLECT, OutputStyle.EVASIVE),
            (InputPattern.VULNERABILITY, CognitiveMode.ANALYZE, OutputStyle.BRIEF),
        ],
        "intellectual": [
            (InputPattern.QUESTION_OPINION, CognitiveMode.ANALYZE, OutputStyle.ELABORATE),
            (InputPattern.CONFRONTATION, CognitiveMode.ANALYZE, OutputStyle.DIRECT),
        ],
        "poetic": [
            (InputPattern.VULNERABILITY, CognitiveMode.REMINISCE, OutputStyle.POETIC),
            (InputPattern.FAREWELL, CognitiveMode.INTUIT, OutputStyle.POETIC),
        ]
    }
    
    @staticmethod
    def compose(block_names: List[str], 
                overrides: Optional[List[ResponseSignature]] = None) -> List[ResponseSignature]:
        """ブロックを組み合わせ、衝突解決して単一のシグネチャリストを生成"""
        combined = []
        for name in block_names:
            combined.extend(PersonaComposer.BLOCKS[name])
        
        # 後勝ちでオーバーライド
        if overrides:
            combined = PersonaComposer._merge_signatures(combined, overrides)
        
        return combined
    
    @staticmethod
    def _merge_signatures(base: List[ResponseSignature], 
                         overrides: List[ResponseSignature]) -> List[ResponseSignature]:
        # InputPatternごとに最後の定義を採用
        sig_map = {s[0]: s for s in base}
        for over in overrides:
            sig_map[over[0]] = over
        return list(sig_map.values())

# 使用例：詩的で防衛的な賢者
sage_persona = PersonaComposer.compose(
    ["intellectual", "poetic", "guarded"],
    overrides=[
        # ただし親しい相手には防衛を解除
        (InputPattern.VULNERABILITY, CognitiveMode.EMPATHIZE, OutputStyle.WARM)
    ]
)
# 結果：[(GREETING,EMPATHIZE,WARM), (QUESTION_OPINION,ANALYZE,ELABORATE), 
#       (CONFRONTATION,ANALYZE,DIRECT), (VULNERABILITY,EMPATHIZE,WARM), ...]

class SignatureOptimizer(dspy.Module):
    """
    期待入出力を満たすようにタグ列を最適化
    """
    def __init__(self, initial_signatures: List[ResponseSignature]):
        self.signatures = initial_signatures
        self.teleprompter = dspy.BootstrapFewShot(
            metric=self._response_match_metric
        )
    
    def _response_match_metric(self, 
                              example: dspy.Example, 
                              pred: dspy.Prediction, 
                              trace=None) -> float:
        """期待出力との一致度を評価"""
        # タグ列が示すべき特性を検証
        score = 0.0
        
        # 1. 出力スタイルの検証（簡潔さ、詩的さなど）
        style_score = self._check_style(pred.output_text, example.signature_tags[2])
        
        # 2. 認知モードの検証（論理性、共感性など）
        cog_score = self._check_cognition(pred.reasoning, example.signature_tags[1])
        
        # 3. 制約条件の検証
        constraint_score = self._check_constraints(pred, example.constraints)
        
        return (style_score + cog_score + constraint_score) / 3
    
    def optimize(self, trainset: List[dspy.Example]) -> List[ResponseSignature]:
        """デモセットから最適なタグ列を学習"""
        # 実際にはタグ自体を調整するか、
        # 各タグに対するプロンプト内容を最適化
        optimized_module = self.teleprompter.compile(
            self, 
            trainset=trainset
        )
        return optimized_module.signatures

class RuntimePersonaController:
    """
    同じタグ列でも文脈で振る舞いを微調整
    """
    def __init__(self, base_signatures: List[ResponseSignature]):
        self.base = base_signatures
        self.context_memory: List[Dict] = []
    
    def generate(self, 
                 input_text: str, 
                 intensity: float = 1.0,  # 0.0-1.0 で特性強度調整
                 drift: Optional[Dict] = None) -> str:
        """
        intensity: タグの特性を強調（1.0）か弱める（0.3）
        drift: 文脈による一時的なモードシフト
        """
        # 基本シグネチャ選択
        pattern = self._detect(input_text)
        base_sig = self._select_signature(pattern)
        
        # 強度適用
        adjusted_sig = self._apply_intensity(base_sig, intensity)
        
        # ドリフト適用（例：疲労でcog_empathizeがcog_deflectに）
        if drift:
            adjusted_sig = self._apply_drift(adjusted_sig, drift)
        
        # 生成
        return self._llm_generate(input_text, adjusted_sig)
    
    def _apply_intensity(self, 
                        sig: ResponseSignature, 
                        intensity: float) -> ResponseSignature:
        """スタイル強度を調整（プロンプトレベルで制御）"""
        inp, cog, out = sig
        # intensityに応じてOutputStyleの表現力を調整
        # 例：WARM x 0.3 = やや冷たい温かさ
        return (inp, cog, (out, intensity))

# Step 1: 最小限のタグセット定義
my_tags = {
    "inputs": ["greeting", "question", "challenge", "share_feeling"],
    "cognition": ["analyze", "empathize", "deflect", "play_along"],
    "outputs": ["brief", "warm", "sharp", "poetic", "silly"]
}

# Step 2: 期待入出力のデモ作成（10-20例）
demos = [
    {"input": "こんにちは", "tags": ("greeting", "empathize", "warm"), 
     "expected": "やあ、会えて嬉しいよ"},
    # ...
]

# Step 3: DSPyモジュール構築と最適化
module = PersonaModule.from_demos(demos)
optimized = SignatureOptimizer(module).optimize(demos)

# Step 4: 実行
response = module("最近調子どう？", context="3回目の会話")

[Input] → [PersonaModule(enumタグ列)] → [Output]
   ↑
[Knowledge?] ← 未統合

from dataclasses import dataclass
from typing import Set, Dict, List, Optional
from enum import Enum, auto

class KnowledgeType(Enum):
    FACT = auto()           # 検証可能事実
    THEORY = auto()         # 理論・モデル
    VALUE = auto()          # 価値判断・倫理
    UNCERTAINTY = auto()    # 不明・確率的情報

@dataclass(frozen=True)  # 不変（議論対象として共有）
class KnowledgeAtom:
    id: str
    content: str
    knowledge_type: KnowledgeType
    confidence: float  # 0.0-1.0
    sources: List[str]  # 出典・根拠
    contradictions: Set[str]  # 矛盾する他のatom_id
    
    # 重要：ペルソナ非依存
    def with_interpretation(self, persona_id: str) -> "InterpretedKnowledge":
        return InterpretedKnowledge(self, persona_id)

@dataclass
class InterpretedKnowledge:
    """知識にペルソナによる解釈を付与"""
    base: KnowledgeAtom
    persona_id: str
    
    # 解釈の次元（これらが論争の源泉）
    salience: float  # どれだけ重視するか（0-1）
    framing: str  # どう枠組むか（例："脅威" vs "機会"）
    emotional_valence: float  # -1(ネガ) ~ +1(ポジ)
    action_implication: List[str]  # 導かれる行動・結論
    
    # 論争生成のためのメソッド
    def generate_counter(self, other: "InterpretedKnowledge") -> Optional[str]:
        """異なる解釈への反論を生成"""
        if self.base.id != other.base.id:
            return None  # 同じ知識についての議論のみ
        
        # 解釈の差異を特定
        if self.salience > 0.7 and other.salience < 0.3:
            return f"{self.base.content}は軽視できない。{self.framing}という側面が見落とされている"
        elif self.emotional_valence * other.emotional_valence < 0:
            return f"同じ事実でも{self.framing}と{other.framing}という読み方がある"
        return None

class DebateMove(Enum):
    ASSERT = auto()         # 主張
    CHALLENGE_FACT = auto() # 事実誤認の指摘
    CHALLENGE_FRAMING = auto()  # 枠組みの問題化
    CONCEDE = auto()        # 譲歩
    REFRAME = auto()        # 再定義・転換
    ESCALATE = auto()       # 抽象レベル引上げ
    GROUND = auto()         # 具体例・証拠提示

@dataclass
class Argument:
    speaker_persona: str
    target_knowledge: Optional[str]  # atom_id
    move: DebateMove
    content: str
    supporting_knowledge: List[str]  # 根拠として使うatom_id
    # 論理的構造（後述の Toulmin Model）
    claim: str
    warrant: str  # 推論の根拠
    backing: List[str]  # warrantの補強
    qualifier: str  # 確実性の修飾（「確実に」「おそらく」）
    rebuttal_reservation: List[str]  # 予想される反論

@dataclass
class Position:
    """
    ペルソナが特定の論題について取る立場
    単なる意見ではなく、知識の選択と解釈の組み合わせ
    """
    thesis: str  # 主論題
    # 知識の選択的重み付け
    knowledge_weights: Dict[str, float]  # atom_id -> importance
    # 解釈パラメータのプリセット
    default_framings: Dict[str, str]  # atom_id -> framing
    # 論争戦略
    preferred_moves: List[DebateMove]
    risk_tolerance: float  # 0=保守的（譲歩しやすい）, 1=攻撃的
    
    def generate_argument(self, 
                         available_knowledge: List[KnowledgeAtom],
                         opponent_position: Optional["Position"]) -> Argument:
        # 知識を選択・解釈
        selected = self._select_knowledge(available_knowledge)
        interpreted = [k.with_interpretation(self.thesis) for k in selected]
        
        # 相手との差異を特定
        if opponent_position:
            counter_target = self._find_disagreement(interpreted, opponent_position)
            move = self._choose_move(counter_target)
        else:
            move = DebateMove.ASSERT
        
        return Argument(
            speaker_persona=self.thesis,
            move=move,
            # ... Toulmin構造の構築
        )

from typing import Literal

DebatePhase = Literal[
    "opening",      # 立場表明
    "clash",        # 直接対立
    "argument",     # 根拠提示
    "rebuttal",     # 反論
    "repair",       # 反論への対処
    "closing"       # 決着・合意形成
]

@dataclass
class DebateState:
    phase: DebatePhase
    history: List[Argument]
    common_ground: Set[str]  # 合意済みatom_id
    contested: Set[str]      # 議論中atom_id
    irreconcilable: Set[str] # 決裂したatom_id
    
    def transition(self, new_argument: Argument) -> "DebateState":
        # フェーズ遷移のロジック
        if new_argument.move == DebateMove.CONCEDE:
            return self._absorb_concession(new_argument)
        elif new_argument.move == DebateMove.CHALLENGE_FRAMING:
            return self._enter_clash(new_argument)
        # ...
    
    def detect_stalemate(self) -> bool:
        # 議論の停滞検出
        return len(self.irreconcilable) > 0 and self._no_progress(3)
    
    def extract_dialectical_synthesis(self) -> Optional[str]:
        # 統合可能か判断
        if self.phase == "closing" and len(self.common_ground) > len(self.contested):
            return self._synthesize()
        return None

@dataclass
class Persona:
    """
    単なるenumタグ列ではなく、知識解釈のための多層構造
    """
    # 層1: 認知的特性（元のenumタグ）
    cognitive_profile: List[ResponseSignature]
    
    # 層2: 知識ドメインの専門性（どの領域に詳しいか）
    expertise_domains: Dict[str, float]  # domain -> confidence
    
    # 層3: 価値的偏り（どの価値を優先するか）
    value_weights: Dict[str, float]  # "efficiency", "fairness", "safety", etc.
    
    # 層4: 社会的・文化的文脈
    cultural_background: Dict[str, any]  # 時代、地域、階層など
    
    def interpret(self, knowledge: KnowledgeAtom) -> InterpretedKnowledge:
        # 層を通じた解釈パイプライン
        salience = self._compute_salience(knowledge)
        framing = self._apply_cultural_framing(knowledge)
        valence = self._apply_value_valence(knowledge)
        
        return InterpretedKnowledge(
            base=knowledge,
            persona_id=id(self),
            salience=salience,
            framing=framing,
            emotional_valence=valence,
            action_implication=self._derive_actions(knowledge, valence)
        )
    
    def _compute_salience(self, k: KnowledgeAtom) -> float:
        # 専門性マッチ × 価値関連性
        domain_match = self.expertise_domains.get(k.domain, 0.1)
        value_match = max(
            self.value_weights.get(v, 0.0) 
            for v in k.implicated_values
        )
        return (domain_match + value_match) / 2

┌─────────────────────────────────────────────────────────┐
│                    Knowledge Base                        │
│  ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐       │
│  │Fact_A   │ │Theory_B │ │Value_C  │ │Uncert_D │       │
│  └─────────┘ └─────────┘ └─────────┘ └─────────┘       │
└─────────────────────────────────────────────────────────┘
                           ↓
        ┌──────────────────┼──────────────────┐
        ↓                  ↓                  ↓
   ┌─────────┐      ┌─────────┐      ┌─────────┐
   │Persona X│      │Persona Y│      │Persona Z│
   │(Expert) │      │(Activist│      │(Skeptic)│
   │         │      │ )       │      │         │
   │•Domain:A│      │•Value:C │      │•Value:  │
   │•Value:B │      │•Framing:│      │ Uncert  │
   │         │      │ justice │      │•Domain:D│
   └────┬────┘      └────┬────┘      └────┬────┘
        │                  │              │
        ↓                  ↓              ↓
   ┌─────────┐      ┌─────────┐      ┌─────────┐
   │Interp_XA│      │Interp_YB│      │Interp_ZD│
   │"Aは機会" │      │"Bは搾取" │      │"Dは不明" │
   └────┬────┘      └────┬────┘      └────┬────┘
        │                  │              │
        └──────────────────┼──────────────┘
                           ↓
                    ┌─────────────┐
                    │ Debate Arena │
                    │             │
                    │ ┌─────────┐ │
                    │ │Argument │ │
                    │ │  X→Y    │ │
                    │ └─────────┘ │
                    │ ┌─────────┐ │
                    │ │Counter  │ │
                    │ │  Y→X    │ │
                    │ └─────────┘ │
                    │ ┌─────────┐ │
                    │ │Synthesis│ │
                    │ │  or     │ │
                    │ │Stalemate│ │
                    │ └─────────┘ │
                    └─────────────┘

# 知識の定義
climate_data = KnowledgeAtom(
    id="temp_rise_2deg",
    content="地球の平均気温は産業革命前比で2度上昇している",
    knowledge_type=KnowledgeType.FACT,
    confidence=0.95,
    sources=["IPCC2023"],
    contradictions=set()
)

# 2つのペルソナ
scientist = Persona(
    cognitive_profile=[(InputPattern.QUESTION, CognitiveMode.ANALYZE, OutputStyle.DIRECT)],
    expertise_domains={"climate_science": 0.9},
    value_weights={"accuracy": 0.9, "urgency": 0.5}
)

activist = Persona(
    cognitive_profile=[(InputPattern.QUESTION, CognitiveMode.EMPATHIZE, OutputStyle.ELABORATE)],
    expertise_domains={"climate_science": 0.4},
    value_weights={"urgency": 0.9, "justice": 0.8, "accuracy": 0.6}
)

# 解釈の生成
sci_view = scientist.interpret(climate_data)
# → salience: 0.9, framing: "measurement_precision", valence: -0.3

act_view = activist.interpret(climate_data)
# → salience: 0.7, framing: "existential_threat", valence: -0.9

# 論争生成
debate = DebateArena([scientist, activist], [climate_data])
debate.start()
# Scientist: "2度上昇は測定誤差の範囲内で、長期トレンドとして評価すべき"
# Activist: "2度という数字は人類存続の危機を示す。行動が必要"
# Scientist: "危機と言うには因果関係の証拠が..."

from dataclasses import dataclass, field
from typing import Set, Dict, List, Optional, Callable, FrozenSet
from enum import Enum, auto
import networkx as nx  # 半順序のグラフ表現用

@dataclass(frozen=True)
class KnowledgeAtom:
    id: str
    content: str
    # 半順序における位置を定義する関係
    prerequisites: FrozenSet[str] = field(default_factory=frozenset)  # 直接依存
    generalizes: FrozenSet[str] = field(default_factory=frozenset)    # より抽象
    instantiates: FrozenSet[str] = field(default_factory=frozenset)   # より具体
    # メタデータ
    domain_tags: FrozenSet[str] = field(default_factory=frozenset)
    complexity_score: float = 1.0  # 計算された複雑さ
    
    def __le__(self, other: "KnowledgeAtom") -> bool:
        """半順序: selfがotherより「低い」または同じレベル"""
        # otherへの到達可能性をチェック
        return self._reachable(other, relation="up")
    
    def __lt__(self, other: "KnowledgeAtom") -> bool:
        """狭義の順序: 厳密に低い"""
        return self <= other and self != other
    
    def _reachable(self, other: "KnowledgeAtom", relation: str) -> bool:
        # BFSで到達可能性をチェック（実装省略）
        pass

class KnowledgePoset:
    """知識の半順序集合（Poset）を管理"""
    
    def __init__(self):
        self.atoms: Dict[str, KnowledgeAtom] = {}
        self.graph = nx.DiGraph()  # ハッセ図（カバー関係のみ）
        self._closure: Optional[nx.DiGraph] = None  # 推移閉包（キャッシュ）
    
    def add_atom(self, atom: KnowledgeAtom):
        self.atoms[atom.id] = atom
        # 関係をエッジとして追加
        for prereq in atom.prerequisites:
            self.graph.add_edge(prereq, atom.id, relation="prerequisite")
        for gen in atom.generalizes:
            self.graph.add_edge(atom.id, gen, relation="generalization")
        for inst in atom.instantiates:
            self.graph.add_edge(inst, atom.id, relation="instantiation")
        self._closure = None  # キャッシュ無効化
    
    def compare(self, a_id: str, b_id: str) -> Optional[int]:
        """aとbを比較。 -1: a<b, 0:  incomparable/=, 1: a>b, None: 非可比"""
        if a_id == b_id:
            return 0
        if self._is_reachable(a_id, b_id):
            return -1
        if self._is_reachable(b_id, a_id):
            return 1
        return None  # 非可比（同じ階層でも別系列）
    
    def _is_reachable(self, source: str, target: str) -> bool:
        if self._closure is None:
            self._closure = nx.transitive_closure(self.graph)
        return self._closure.has_edge(source, target)
    
    def upper_set(self, atom_id: str) -> Set[str]:
        """atomより「上」の全知識（包含関係で広いもの）"""
        return nx.descendants(self._get_closure(), atom_id) | {atom_id}
    
    def lower_set(self, atom_id: str) -> Set[str]:
        """atomより「下」の全知識（前提となるもの）"""
        return nx.ancestors(self._get_closure(), atom_id) | {atom_id}
    
    def incomparable_set(self, atom_id: str) -> Set[str]:
        """atomと非可比な知識（別次元の専門性）"""
        all_ids = set(self.atoms.keys())
        comparable = self.upper_set(atom_id) | self.lower_set(atom_id)
        return all_ids - comparable - {atom_id}
    
    def _get_closure(self) -> nx.DiGraph:
        if self._closure is None:
            self._closure = nx.transitive_closure(self.graph)
        return self._closure
    
    def height(self, atom_id: str) -> int:
        """最長鎖の長さ（「深さ」の指標）"""
        # 最長パス長を計算
        lower = self.lower_set(atom_id)
        if len(lower) == 1:
            return 0
        subgraph = self._get_closure().subgraph(lower)
        return nx.dag_longest_path_length(subgraph)
    
    def width_at_level(self, atom_id: str) -> int:
        """同じ「高さ」にある非可比要素の数（そのレベルの広がり）"""
        h = self.height(atom_id)
        same_height = [
            a for a in self.atoms 
            if self.height(a) == h and self.compare(a, atom_id) is None
        ]
        return len(same_height)

# 具体例：物理学の知識ネットワーク
physics_knowledge = KnowledgePoset()

# 層1：観察・現象
physics_knowledge.add_atom(KnowledgeAtom(
    id="falling_apple",
    content="リンゴが地面に落ちる観察",
    domain_tags={"mechanics", "observation"},
    complexity_score=1.0
))

# 層2：法則（複数の観察を統合）
physics_knowledge.add_atom(KnowledgeAtom(
    id="gravity_law_empirical",
    content="物体は地球に引かれる（経験則）",
    prerequisites={"falling_apple", "projectile_motion"},
    domain_tags={"mechanics", "empirical_law"},
    complexity_score=2.0
))

# 層3：理論（法則を説明するモデル）
physics_knowledge.add_atom(KnowledgeAtom(
    id="newtonian_gravity",
    content="万有引力：F=GMm/r²、距離の二乗に反比例",
    prerequisites={"gravity_law_empirical", "calculus"},
    generalizes={"gravity_law_empirical"},  # より抽象
    domain_tags={"mechanics", "theory", "mathematical"},
    complexity_score=4.0
))

# 層4：より抽象的理论（複数の理論を統合）
physics_knowledge.add_atom(KnowledgeAtom(
    id="general_relativity",
    content="時空の曲率としての重力",
    prerequisites={"newtonian_gravity", "differential_geometry", "special_relativity"},
    generalizes={"newtonian_gravity", "special_relativity"},
    domain_tags={"mechanics", "fundamental_theory", "geometrical"},
    complexity_score=7.0
))

# 層5：具体化・応用（理論の特殊解）
physics_knowledge.add_atom(KnowledgeAtom(
    id="black_hole_solution",
    content="シュワルツシルト解：非回転ブラックホール",
    prerequisites={"general_relativity", "spherical_symmetry"},
    instantiates={"general_relativity"},  # GRの具体例
    domain_tags={"mechanics", "exact_solution", "astrophysics"},
    complexity_score=6.0  # 理論より低い場合もある
))

@dataclass
class KnowledgePosition:
    """
    エージェントが半順序のどこに「立っている」か
    単一レベルではなく、下界・上界・重点領域で定義
    """
    agent_id: str
    
    # 確実に知っている知識（下界）
    lower_boundary: Set[str]  # これらとその下位は全て掌握
    
    # 知識の限界（上界）
    upper_boundary: Set[str]  # これらは部分的にのみ知る、または知らない
    
    # 重点領域（非可比な知識の中で専門とするもの）
    focus_domains: Set[str]
    
    # 「知っている」という関係の曖昧さ
    certainty_map: Dict[str, float]  # atom_id -> 確信度[0,1]
    
    def knows(self, atom_id: str, poset: KnowledgePoset) -> float:
        """atom_idをどれだけ知っているか（0-1）"""
        # 下界に含まれれば1.0
        if atom_id in self.lower_boundary:
            return 1.0
        
        # 前提知識が全て下界にあれば、推論可能
        atom = poset.atoms[atom_id]
        prereqs_satisfied = all(
            p in self.lower_boundary or self.knows(p, poset) > 0.8
            for p in atom.prerequisites
        )
        
        if not prereqs_satisfied:
            return 0.0
        
        # 前提はあるが、atom自体が上界や非可比領域
        if atom_id in self.upper_boundary:
            return self.certainty_map.get(atom_id, 0.3)
        
        # 非可比領域：ドメイン一致で部分的知識
        if atom.domain_tags & self.focus_domains:
            return 0.5  # 転用可能な知識
        
        return 0.0
    
    def can_explain(self, target_id: str, to_position: "KnowledgePosition", 
                   poset: KnowledgePoset) -> Optional[List[str]]:
        """target_idをto_positionに説明可能か（経路を返す）"""
        # 共通の下界を見つける
        common_lower = self.lower_boundary & to_position.lower_boundary
        
        # target_idへの経路を探索
        target_atom = poset.atoms[target_id]
        required_prereqs = target_atom.prerequisites
        
        # 相手が知らない前提を特定
        unknown_to_them = required_prereqs - to_position.lower_boundary
        
        # 自分がそれらを知っていれば説明可能
        if unknown_to_them <= self.lower_boundary:
            # 説明経路を構築（トポロジカルソート）
            return self._build_explanation_path(target_id, unknown_to_them, poset)
        
        return None  # 説明不可（自分も知らない、または相手の前提が不足）
    
    def _build_explanation_path(self, target: str, gaps: Set[str], 
                                poset: KnowledgePoset) -> List[str]:
        """説明の順序を最適化（前提から順に）"""
        # 半順序に従ったトポロジカルソート
        subgraph = poset.graph.subgraph(gaps | {target})
        return list(nx.topological_sort(subgraph))

class KnowledgeDebate:
    """知識の半順序を使った構造化論争"""
    
    def __init__(self, poset: KnowledgePoset, 
                 position_a: KnowledgePosition,
                 position_b: KnowledgePosition):
        self.poset = poset
        self.a = position_a
        self.b = position_b
        
        # 知識の位置関係を分析
        self.relation = self._analyze_positions()
    
    def _analyze_positions(self) -> Dict:
        """2つの位置の構造関係を分類"""
        a_lower = self.a.lower_boundary
        b_lower = self.b.lower_boundary
        
        # 包含関係チェック
        if a_lower <= b_lower:
            return {"type": "a_dominates", "gap": b_lower - a_lower}
        if b_lower <= a_lower:
            return {"type": "b_dominates", "gap": a_lower - b_lower}
        
        # 非可比：共通部分と差分
        common = a_lower & b_lower
        a_only = a_lower - b_lower
        b_only = b_lower - b_lower
        
        # 差分が非可比か、順序があるか
        incomparable = True
        for a_atom in a_only:
            for b_atom in b_only:
                if self.poset.compare(a_atom, b_atom) is not None:
                    incomparable = False
        
        return {
            "type": "incomparable" if incomparable else "partial_order",
            "common": common,
            "a_unique": a_only,
            "b_unique": b_only
        }
    
    def generate_debate_moves(self) -> List[Dict]:
        """位置関係に基づく論争手を生成"""
        moves = []
        rel = self.relation
        
        if rel["type"] == "a_dominates":
            # AはBの上位知識を持つ
            moves.append({
                "speaker": "a",
                "move": "foundational_challenge",
                "content": f"あなたの前提{rel['gap']}はより根本的な{self._find_generalization(rel['gap'])}に還元可能",
                "target_knowledge": list(rel["gap"])
            })
        
        elif rel["type"] == "incomparable":
            # 非可比：異なるパラダイム間の対話
            bridge = self._find_bridge(rel["a_unique"], rel["b_unique"])
            if bridge:
                moves.append({
                    "speaker": "a",
                    "move": "bridge_proposal",
                    "content": f"両者は{bridge}という共通の抽象概念で統合可能",
                    "bridge_atom": bridge
                })
            else:
                moves.append({
                    "speaker": "a",
                    "move": "paradigm_incommensurability",
                    "content": "私たちの前提は異なるパラダイムに属し、直接比較不能かもしれない",
                    "suggestion": "各パラダイムの適用領域を明確にせよ"
                })
        
        return moves
    
    def _find_generalization(self, atoms: Set[str]) -> Optional[str]:
        """与えられた知識の共通抽象を見つける"""
        # atomsを包含する最小のupper_set共通部分
        upper_sets = [self.poset.upper_set(a) for a in atoms]
        common_upper = set.intersection(*upper_sets) if upper_sets else set()
        # 最小元（最も具体的な共通抽象）を返す
        return min(common_upper, key=lambda x: self.poset.height(x)) if common_upper else None
    
    def _find_bridge(self, a_set: Set[str], b_set: Set[str]) -> Optional[str]:
        """2つの知識集合を結ぶ橋渡し知識を見つける"""
        # a_setの上位とb_setの上位の交差を探索
        a_upper = set.union(*[self.poset.upper_set(a) for a in a_set])
        b_upper = set.union(*[self.poset.upper_set(b) for b in b_set])
        bridges = a_upper & b_upper
        # 最も低い（具体的な）橋を選択
        return min(bridges, key=lambda x: self.poset.height(x), default=None)

class StructuredInference:
    """
    ニューラル「プロンプト」ではなく、
    半順序構造を使った決定論的・構造的推論
    """
    
    def __init__(self, poset: KnowledgePoset):
        self.poset = poset
        # 推論ルールを宣言的に定義
        self.rules: List[Callable] = [
            self._modus_ponens_poset,      # 順序に基づく三段論法
            self._abduction_upward,         # 上向き仮説形成
            self._analogy_incomparable,    # 非可比間の類推
            self._synthesis_common_upper,   # 共通上界での統合
        ]
    
    def _modus_ponens_poset(self, 
                           known: Set[str], 
                           target: str) -> Optional[List[str]]:
        """半順序版三段論法: 前提が下位にあれば結論が上位に従う"""
        if target in known:
            return []
        
        target_atom = self.poset.atoms[target]
        # 全ての前提がknownに含まれ、targetがその上界なら
        if target_atom.prerequisites <= known:
            # 推論経路 = 前提のトポロジカルソート + 結論
            path = self.poset.sort_by_order(target_atom.prerequisites)
            return path + [target]
        
        return None
    
    def _abduction_upward(self,
                         observations: Set[str],
                         hypotheses: Set[str]) -> List[str]:
        """観察を説明する最も低い仮説（上界）を探索"""
        candidates = []
        for hyp in hypotheses:
            hyp_atom = self.poset.atoms[hyp]
            # hypがobservationsの上界かチェック
            if all(self.poset.compare(obs, hyp) == -1 for obs in observations):
                candidates.append((hyp, self.poset.height(hyp)))
        
        # 最小の高さ（最も具体的な説明）を選択
        candidates.sort(key=lambda x: x[1])
        return [c[0] for c in candidates]
    
    def _analogy_incomparable(self,
                             source: str,
                             target_domain: str) -> Optional[str]:
        """非可比な領域間での構造類推"""
        source_atom = self.poset.atoms[source]
        # sourceと非可比で、target_domainに属する知識を探す
        analogs = [
            a for a in self.poset.incomparable_set(source)
            if target_domain in self.poset.atoms[a].domain_tags
        ]
        
        # 構造の類似性（前提数、抽象度など）でスコアリング
        def structural_similarity(a: str) -> float:
            atom = self.poset.atoms[a]
            src = source_atom
            score = 0.0
            # 前提数の類似
            score += 1.0 - abs(len(atom.prerequisites) - len(src.prerequisites)) / 5
            # 高さの類似
            score += 1.0 - abs(self.poset.height(a) - self.poset.height(source)) / 5
            return score
        
        if analogs:
            return max(analogs, key=structural_similarity)
        return None
    
    def reason(self, 
               agent_position: KnowledgePosition,
               goal: str,
               constraints: Set[str]) -> Optional[Dict]:
        """構造的推論の実行"""
        known = agent_position.lower_boundary
        
        # 各ルールを適用可能かチェック
        for rule in self.rules:
            result = rule(known, goal)
            if result:
                return {
                    "rule": rule.__name__,
                    "path": result,
                    "gaps": set(result) - known,
                    "confidence": agent_position.knows(goal, self.poset)
                }
        
        # 推論不可：知識のギャップを特定
        return {
            "rule": "insufficient_knowledge",
            "missing_prerequisites": self._find_missing_prerequisites(goal, known),
            "suggested_learning_path": self._suggest_learning_path(goal, agent_position)
        }
    
    def _find_missing_prerequisites(self, target: str, known: Set[str]) -> Set[str]:
        target_atom = self.poset.atoms[target]
        missing = target_atom.prerequisites - known
        # 再帰的に前提の前提も探索
        all_missing = set()
        for m in missing:
            all_missing |= self._find_missing_prerequisites(m, known)
        return all_missing | missing
    
    def _suggest_learning_path(self, target: str, position: KnowledgePosition) -> List[str]:
        """目標達成のための学習経路（半順序に従った最短パス）"""
        missing = self._find_missing_prerequisites(target, position.lower_boundary)
        # トポロジカルソートで学習順序を決定
        subgraph = self.poset.graph.subgraph(missing | {target})
        return list(nx.topological_sort(subgraph))

@dataclass
class DebateAgent:
    """知識半順序上の位置と推論能力を持つエージェント"""
    
    agent_id: str
    persona: Persona  # 前回定義した振る舞い様式
    knowledge_position: KnowledgePosition  # 知識の位置
    inference_engine: StructuredInference  # 推論ルール
    
    def respond(self, 
                input_text: str,
                debate_context: DebateState,
                opponent_position: KnowledgePosition) -> Dict:
        
        # 1. 入力を知識アトムにマッピング
        mentioned_knowledge = self._extract_knowledge_references(input_text)
        
        # 2. 自分の位置から見た解釈
        interpretations = {
            k: self._interpret_from_position(k) 
            for k in mentioned_knowledge
        }
        
        # 3. 相手位置との関係分析
        debate = KnowledgeDebate(
            self.inference_engine.poset,
            self.knowledge_position,
            opponent_position
        )
        
        # 4. 論争手の選択
        available_moves = debate.generate_debate_moves()
        selected_move = self.persona.select_move(available_moves, debate_context)
        
        # 5. 推論による補強
        if selected_move.get("requires_inference"):
            inference_result = self.inference_engine.reason(
                self.knowledge_position,
                selected_move["target_knowledge"],
                debate_context.accepted_knowledge
            )
            selected_move["inference_support"] = inference_result
        
        # 6. ペルソナによる言語化
        response_text = self.persona.verbalize(
            selected_move,
            interpretations,
            debate_context
        )
        
        return {
            "move": selected_move,
            "interpretations": interpretations,
            "response": response_text,
            "knowledge_gaps": debate.relation  # 相手との知識差
        }
    
    def _interpret_from_position(self, atom_id: str) -> Dict:
        """自分の知識位置から見たatom_idの意味"""
        knows = self.knowledge_position.knows(atom_id, self.inference_engine.poset)
        atom = self.inference_engine.poset.atoms[atom_id]
        
        return {
            "certainty": knows,
            "viewed_as": "axiom" if knows == 1.0 else 
                        "derived" if knows > 0.5 else 
                        "foreign" if knows == 0.0 else "uncertain",
            "can_explain_to": self._who_can_explain_to(atom_id),
            "needs_explanation_from": None if knows > 0.5 else 
                                     self._who_has_this(atom_id)
        }

from dataclasses import dataclass, field
from typing import Dict, List, Tuple, Optional, Set
from enum import Enum, auto
import numpy as np
from datetime import datetime, timedelta

class CognitiveDimension(Enum):
    """知能・能力の分解次元"""
    # 記憶系
    ROTE_MEMORY = "rote_memory"           # 暗記・想起
    EPISODIC_MEMORY = "episodic_memory"    # 経験記憶
    PROCEDURAL_MEMORY = "procedural"       # 手続き記憶
    
    # 推論系
    CAUSAL_INFERENCE = "causal"            # 因果推論（歴史で言う「なぜ」）
    ANALOGICAL_TRANSFER = "analogical"     # 類推転移
    ABDUCTIVE_REASONING = "abductive"      # 仮説形成
    
    # 処理系
    WORKING_MEMORY_CAPACITY = "working_mem" #  working memory span
    PROCESSING_SPEED = "speed"             # 処理速度
    COGNITIVE_FLEXIBILITY = "flexibility"  # 柔軟性
    
    # 知識系
    DECLARATIVE_KNOWLEDGE = "declarative"  # 事実知識
    PROCEDURAL_KNOWLEDGE = "procedural_k"  # 手続き知識
    METACOGNITION = "metacognition"        # 自己監視

@dataclass
class AbilityProfile:
    """
    特定時点での能力分布（多変量正規分布としてモデル化）
    平均と分散、次元間の共分散を保持
    """
    timestamp: datetime
    means: Dict[CognitiveDimension, float]  # -3 ~ +3 (標準化スコア)
    variances: Dict[CognitiveDimension, float]
    correlations: Dict[Tuple[CognitiveDimension, CognitiveDimension], float]
    
    # 信頼度（データの質に依存）
    confidence: Dict[CognitiveDimension, float]  # 0.0-1.0
    
    def sample(self, n: int = 1) -> List[Dict[CognitiveDimension, float]]:
        """分布から能力パターンをサンプリング（モンテカルロ）"""
        dims = list(CognitiveDimension)
        mean_vec = np.array([self.means[d] for d in dims])
        
        # 共分散行列構築
        cov_matrix = np.zeros((len(dims), len(dims)))
        for i, d1 in enumerate(dims):
            for j, d2 in enumerate(dims):
                if i == j:
                    cov_matrix[i, j] = self.variances[d]
                else:
                    corr = self.correlations.get((d1, d2), 
                           self.correlations.get((d2, d1), 0.0))
                    cov_matrix[i, j] = corr * np.sqrt(self.variances[d1] * self.variances[d2])
        
        samples = np.random.multivariate_normal(mean_vec, cov_matrix, n)
        return [{d: samples[k, i] for i, d in enumerate(dims)} for k in range(n)]
    
    def get_stereotype_pattern(self) -> str:
        """分布からステレオタイプ的能力パターンを抽出"""
        # 上位2-3の強みと弱みを特定
        sorted_dims = sorted(self.means.items(), key=lambda x: x[1], reverse=True)
        strengths = [d for d, v in sorted_dims if v > 1.0][:3]
        weaknesses = [d for d, v in sorted_dims if v < -1.0][:2]
        
        return self._pattern_to_label(strengths, weaknesses)
    
    def _pattern_to_label(self, strengths: List[CognitiveDimension], 
                         weaknesses: List[CognitiveDimension]) -> str:
        # パターンラベルの生成（例：「暗記型・因果弱・類推強」）
        if CognitiveDimension.ROTE_MEMORY in strengths and \
           CognitiveDimension.CAUSAL_INFERENCE in weaknesses:
            return "rote_heavy_causal_weak"
        if CognitiveDimension.ANALOGICAL_TRANSFER in strengths and \
           CognitiveDimension.PROCESSING_SPEED in weaknesses:
            return "deep_slow_thinker"
        # ... 他のパターン
        return "balanced_mixed"

@dataclass
class HistoricalObservation:
    """
    「赤点を取った」などの観測事実
    これを能力分布へのエビデンスとして変換
    """
    timestamp: datetime
    context: str  # "junior_high_history_test"
    observed_outcome: str  # "failed_red_mark"
    
    # 観測が示唆する能力関係
    implicated_dimensions: Set[CognitiveDimension]
    direction: str  # "deficit" or "strength"
    severity: float  # -3.0 ~ +3.0
    
    # 観測の信頼度（テストの質、偽陽性リスク）
    reliability: float  # 0.0-1.0

class ProfileEstimator:
    """観測履歴から能力分布を推定"""
    
    def __init__(self):
        # 観測タイプ → 能力への影響マッピング（事前知識）
        self.observation_templates = {
            "history_test_red": {
                "implicated": {
                    CognitiveDimension.ROTE_MEMORY: -0.5,  # 暗記弱い？
                    CognitiveDimension.CAUSAL_INFERENCE: -1.5,  # または因果弱い？
                    CognitiveDimension.WORKING_MEMORY_CAPACITY: -0.3,
                },
                "discrimination": "causal_vs_rote",  # どちらかを区別する必要あり
                "base_rate": 0.15  # 赤点の基礎確率
            },
            "math_quick_solving": {
                "implicated": {
                    CognitiveDimension.PROCESSING_SPEED: 1.2,
                    CognitiveDimension.PROCEDURAL_KNOWLEDGE: 1.0,
                    CognitiveDimension.CAUSAL_INFERENCE: 0.3,
                }
            }
        }
    
    def estimate_profile(self, 
                        observations: List[HistoricalObservation]) -> AbilityProfile:
        """観測列から事後分布を構築"""
        
        # 時系列でソート
        sorted_obs = sorted(observations, key=lambda x: x.timestamp)
        
        # 各時点での分布を更新（カルマンフィルタ的アプローチ）
        current_means = {d: 0.0 for d in CognitiveDimension}
        current_vars = {d: 1.0 for d in CognitiveDimension}  # 事前分散
        
        for obs in sorted_obs:
            template = self.observation_templates.get(obs.context, {})
            
            # 観測の時間減衰（古い観測は不確実）
            time_decay = self._compute_decay(obs.timestamp, 
                                           datetime.now(), 
                                           half_life_years=2.0)
            
            for dim, impact in template.get("implicated", {}).items():
                # ベイズ更新
                prior_mean = current_means[dim]
                prior_var = current_vars[dim]
                
                likelihood_mean = impact * obs.severity
                likelihood_var = (1 - obs.reliability) * 2.0  # 観測誤差
                
                # 事後分布計算
                posterior_var = 1 / (1/prior_var + 1/likelihood_var * time_decay)
                posterior_mean = posterior_var * (prior_mean/prior_var + 
                                                 likelihood_mean/likelihood_var * time_decay)
                
                current_means[dim] = posterior_mean
                current_vars[dim] = posterior_var
        
        # 共分散構造の推定（観測間の相関から）
        correlations = self._estimate_correlations(sorted_obs)
        
        return AbilityProfile(
            timestamp=datetime.now(),
            means=current_means,
            variances=current_vars,
            correlations=correlations,
            confidence={d: 1/v for d, v in current_vars.items()}  # 逆分散=信頼度
        )
    
    def _compute_decay(self, obs_time: datetime, now: datetime, half_life_years: float) -> float:
        """時間減衰係数（能力は変化する）"""
        years_passed = (now - obs_time).days / 365.25
        return 0.5 ** (years_passed / half_life_years)
    
    def _estimate_correlations(self, observations: List[HistoricalObservation]) -> Dict:
        """観測パターンから能力間の相関を推定"""
        # 例：「歴史で赤点、数学で満点」→ 暗記と論理の負の相関
        # 簡易実装：事前定義された相関マトリクスを使用
        return {
            (CognitiveDimension.ROTE_MEMORY, CognitiveDimension.CAUSAL_INFERENCE): -0.4,
            (CognitiveDimension.PROCESSING_SPEED, CognitiveDimension.METACOGNITION): -0.2,
            (CognitiveDimension.ANALOGICAL_TRANSFER, CognitiveDimension.ABDUCTIVE_REASONING): 0.6,
        }

@dataclass
class KnowledgeStereotype:
    """
    能力パターンから現在の知識位置をステレオタイプ的に推定
    「こういう能力分布の人は、こういう知識位置にいることが多い」
    """
    pattern_label: str  # "rote_heavy_causal_weak" など
    ability_signature: Dict[CognitiveDimension, Tuple[float, float]]  # (mean, std)
    
    # 連想される知識位置の特徴
    typical_knowledge_position: Dict[str, any]
    
    # 成長軌道（時間発展）
    growth_trajectory: List[Tuple[float, Dict[str, any]]]  # (years_later, position_change)
    
    # 信頼区間
    confidence_interval: float  # 0.95 など

class StereotypeMapper:
    """能力プロファイル → 知識位置の連想エンジン"""
    
    def __init__(self, poset: KnowledgePoset):
        self.poset = poset
        self.stereotypes: Dict[str, KnowledgeStereotype] = self._load_stereotypes()
    
    def _load_stereotypes(self) -> Dict[str, KnowledgeStereotype]:
        # 事前定義されたステレオタイプ
        return {
            "rote_heavy_causal_weak": KnowledgeStereotype(
                pattern_label="rote_heavy_causal_weak",
                ability_signature={
                    CognitiveDimension.ROTE_MEMORY: (1.5, 0.5),
                    CognitiveDimension.CAUSAL_INFERENCE: (-1.2, 0.8),
                    CognitiveDimension.DECLARATIVE_KNOWLEDGE: (1.0, 0.6),
                },
                typical_knowledge_position={
                    "lower_boundary": {
                        "historical_dates", "event_sequences",  # 暗記系は充実
                        "basic_chronology",
                    },
                    "upper_boundary": {
                        "historical_causation", "structural_analysis",  # 因果系は限界
                        "counterfactual_history",
                    },
                    "focus_domains": {"descriptive_history", "fact_retrieval"},
                    "avoided_patterns": ["why_questions", "systemic_analysis"]
                },
                growth_trajectory=[
                    (2.0, {  # 2年後の典型的発展
                        "lower_boundary_add": ["causal_heuristics"],
                        "upper_boundary_shift": ["simple_causation"],
                        "certainty_decay": 0.3  # 暗記の陳腐化
                    }),
                    (5.0, {
                        "pattern_transition": "rote_to_pattern_based",
                        "new_stereotype": "pattern_based_thinker"
                    })
                ],
                confidence_interval=0.85
            ),
            
            "deep_slow_thinker": KnowledgeStereotype(
                pattern_label="deep_slow_thinker",
                ability_signature={
                    CognitiveDimension.ANALOGICAL_TRANSFER: (1.3, 0.6),
                    CognitiveDimension.PROCESSING_SPEED: (-0.8, 0.5),
                    CognitiveDimension.METACOGNITION: (0.9, 0.7),
                },
                typical_knowledge_position={
                    "lower_boundary": {
                        "deep_structures", "cross_domain_patterns",
                        "methodology_epistemology",
                    },
                    "upper_boundary": {
                        "quick_fact_recall", "rapid_assessment",
                        "trivia_knowledge",
                    },
                    "focus_domains": {"theoretical_frameworks", "paradigm_analysis"},
                    "processing_characteristic": "slow_but_deep"
                },
                growth_trajectory=[
                    (3.0, {
                        "compensatory_development": "speed_improvement_strategies",
                        "lower_boundary_add": ["automated_pattern_recognition"]
                    })
                ],
                confidence_interval=0.80
            )
        }
    
    def map_profile_to_position(self, 
                                 profile: AbilityProfile,
                                 years_elapsed: float = 0.0) -> List[Tuple[str, float, Dict]]:
        """
        能力プロファイルを知識位置にマッピング
        複数のステレオタイプを確率的に返す
        """
        # パターンマッチングスコア計算
        scores = []
        for label, stereotype in self.stereotypes.items():
            score = self._compute_match_score(profile, stereotype)
            scores.append((label, score, stereotype))
        
        # 時間発展を適用
        results = []
        for label, base_score, stereotype in sorted(scores, key=lambda x: x[1], reverse=True):
            evolved_position = self._apply_growth(
                stereotype.typical_knowledge_position,
                stereotype.growth_trajectory,
                years_elapsed
            )
            time_decay = 0.9 ** years_elapsed  # 古い観測に基づく推定は不確実
            final_confidence = base_score * stereotype.confidence_interval * time_decay
            
            results.append((label, final_confidence, evolved_position))
        
        return results  # [(stereotype_label, confidence, position), ...]
    
    def _compute_match_score(self, 
                             profile: AbilityProfile, 
                             stereotype: KnowledgeStereotype) -> float:
        """能力分布の類似度を計算"""
        score = 0.0
        for dim, (target_mean, target_std) in stereotype.ability_signature.items():
            obs_mean = profile.means.get(dim, 0.0)
            obs_var = profile.variances.get(dim, 1.0)
            
            # マハラノビス距離のような類似度
            distance = abs(obs_mean - target_mean) / np.sqrt(obs_var + target_std**2)
            dim_score = max(0, 1 - distance / 3)  # 3シグマで0
            
            score += dim_score * profile.confidence.get(dim, 0.5)
        
        return score / len(stereotype.ability_signature)
    
    def _apply_growth(self, 
                      base_position: Dict,
                      trajectory: List[Tuple[float, Dict]],
                      years: float) -> Dict:
        """成長軌道を適用"""
        position = base_position.copy()
        
        for t, changes in trajectory:
            if years >= t:
                # 変更を適用
                if "lower_boundary_add" in changes:
                    position["lower_boundary"] = position.get("lower_boundary", set()) | set(changes["lower_boundary_add"])
                if "pattern_transition" in changes:
                    position["current_stage"] = changes["pattern_transition"]
        
        position["years_from_observation"] = years
        return position

@dataclass
class SituatedKnowledgePosition:
    """
    時系列を含む知識位置
    「現在ここにいる」だけでなく、「こういう経緯でここに至った」
    """
    # 現在の知識位置（半順序上）
    current_position: KnowledgePosition
    
    # 生成された「履歴」（観測から推定された能力分布の時系列）
    inferred_history: List[Tuple[datetime, AbilityProfile, str]]  # (time, profile, stereotype_label)
    
    # 現在の特性（能力分布から導かれた処理特性）
    processing_profile: Dict[str, any]
    
    # プロンプト生成用の「物語」
    backstory_narrative: str

class SituatedPositionGenerator:
    """観測履歴から「 situated 」な知識位置を生成"""
    
    def __init__(self, estimator: ProfileEstimator, mapper: StereotypeMapper):
        self.estimator = estimator
        self.mapper = mapper
    
    def generate(self, 
                 observations: List[HistoricalObservation],
                 current_date: Optional[datetime] = None) -> SituatedKnowledgePosition:
        
        current_date = current_date or datetime.now()
        
        # Step 1: 能力分布の推定
        current_profile = self.estimator.estimate_profile(observations)
        
        # Step 2: 時系列再構築（過去の分布を逆算）
        history = self._reconstruct_history(observations, current_profile)
        
        # Step 3: 現在位置へのマッピング
        years_elapsed = (current_date - observations[0].timestamp).days / 365.25
        stereotype_matches = self.mapper.map_profile_to_position(current_profile, years_elapsed)
        
        best_match = stereotype_matches[0]  # 最確実なステレオタイプ
        stereotype_label, confidence, position_spec = best_match
        
        # Step 4: KnowledgePositionの構築
        current_knowledge_pos = self._build_knowledge_position(position_spec)
        
        # Step 5: 処理特性の導出
        processing = self._derive_processing_profile(current_profile)
        
        # Step 6: 物語の生成（プロンプト用）
        narrative = self._generate_backstory(history, stereotype_label, confidence)
        
        return SituatedKnowledgePosition(
            current_position=current_knowledge_pos,
            inferred_history=history,
            processing_profile=processing,
            backstory_narrative=narrative
        )
    
    def _reconstruct_history(self, 
                             observations: List[HistoricalObservation],
                             current: AbilityProfile) -> List[Tuple[datetime, AbilityProfile, str]]:
        """観測点での能力分布を再構築"""
        history = []
        for obs in observations:
            # その時点での分布を推定（現在から逆算）
            time_diff = (datetime.now() - obs.timestamp).days / 365.25
            decay_factor = 0.7 ** time_diff  # 成長を逆算
            
            past_profile = AbilityProfile(
                timestamp=obs.timestamp,
                means={d: v * decay_factor for d, v in current.means.items()},
                variances={d: v / decay_factor for d, v in current.variances.items()},
                correlations=current.correlations,
                confidence={d: c * decay_factor for d, c in current.confidence.items()}
            )
            
            # その時点でのステレオタイプ
            past_matches = self.mapper.map_profile_to_position(past_profile, 0)
            label = past_matches[0][0] if past_matches else "unknown"
            
            history.append((obs.timestamp, past_profile, label))
        
        return history
    
    def _derive_processing_profile(self, profile: AbilityProfile) -> Dict:
        """能力分布から処理特性を導出"""
        means = profile.means
        
        return {
            "response_latency": "slow" if means[CognitiveDimension.PROCESSING_SPEED] < -0.5 else "fast",
            "explanation_style": "step_by_step" if means[CognitiveDimension.METACOGNITION] > 0.5 else "intuitive",
            "error_pattern": "careless" if means[CognitiveDimension.WORKING_MEMORY_CAPACITY] > 1.0 and 
                                          means[CognitiveDimension.METACOGNITION] < 0 
                           else "confused",
            "learning_strategy": "memorization_first" if means[CognitiveDimension.ROTE_MEMORY] > means[CognitiveDimension.CAUSAL_INFERENCE]
                                else "understanding_first",
            "knowledge_organization": "hierarchical" if means[CognitiveDimension.ANALOGICAL_TRANSFER] > 0.5
                                     else "linear_chronological"
        }
    
    def _generate_backstory(self, 
                           history: List[Tuple[datetime, AbilityProfile, str]],
                           current_label: str,
                           confidence: float) -> str:
        """プロンプト用の背景物語を生成"""
        if not history:
            return "能力分布の履歴不明"
        
        # 主要な転換点を特定
        transitions = []
        prev_label = history[0][2]
        for time, profile, label in history[1:]:
            if label != prev_label:
                transitions.append((time, prev_label, label))
                prev_label = label
        
        # 物語構築
        parts = []
        first_time, first_profile, first_label = history[0]
        parts.append(f"初期の能力パターンは「{first_label}」型で、"
                    f"{first_time.year}年頃の観測において"
                    f"暗記力は{first_profile.means[CognitiveDimension.ROTE_MEMORY]:.1f}、"
                    f"因果推論は{first_profile.means[CognitiveDimension.CAUSAL_INFERENCE]:.1f}だった。")
        
        for trans_time, from_l, to_l in transitions:
            parts.append(f"{trans_time.year}年頃、「{from_l}」から「{to_l}」へと"
                        f"能力パターンが転換した跡がある。")
        
        parts.append(f"現在は「{current_label}」型と推定され（確信度{confidence:.2f}）、"
                    f"このパターンに典型的な知識構造と推論特性を持つ。")
        
        return " ".join(parts)

def create_persona_prompt(situated: SituatedKnowledgePosition, 
                          debate_topic: Optional[str] = None) -> str:
    """LLMへのプロンプトを生成"""
    
    pos = situated.current_position
    proc = situated.processing_profile
    
    prompt_parts = [
        "# 知識的位置と能力プロファイル",
        "",
        "## 背景（推定された発達経緯）",
        situated.backstory_narrative,
        "",
        "## 現在の知識境界",
        f"- 確実に掌握: {', '.join(list(pos.lower_boundary)[:5])}...",
        f"- 限界・不安定: {', '.join(list(pos.upper_boundary)[:3])}...",
        f"- 重点領域: {', '.join(pos.focus_domains)}",
        "",
        "## 認知的処理特性",
        f"- 応答速度: {proc['response_latency']}",
        f"- 説明スタイル: {proc['explanation_style']}",
        f"- 誤りパターン: {proc['error_pattern']}",
        f"- 学習戦略: {proc['learning_strategy']}",
        f"- 知識編成: {proc['knowledge_organization']}",
        "",
        "## 議論における制約",
        "以下の特性に従って発言してください：",
        f"1. 因果推論の複雑さは「{proc.get('causal_complexity_limit', '中程度')}」に制限",
        f"2. 反論時には「{proc['explanation_style']}」で説明を試みる",
        f"3. 不確実な知識に触れる際は「{proc.get('uncertainty_expression', '婉曲表現')}」を使用",
    ]
    
    if debate_topic:
        prompt_parts.extend([
            "",
            f"## 議論テーマ: {debate_topic}",
            "上記の知識位置と能力プロファイルから、自然な発言を生成してください。"
        ])
    
    return "\n".join(prompt_parts)

# 使用例
observations = [
    HistoricalObservation(
        timestamp=datetime(2015, 7, 1),  # 中学3年
        context="history_test_red",
        observed_outcome="failed_red_mark",
        implicated_dimensions={CognitiveDimension.CAUSAL_INFERENCE, CognitiveDimension.ROTE_MEMORY},
        direction="deficit",
        severity=-2.0,
        reliability=0.8
    ),
    HistoricalObservation(
        timestamp=datetime(2018, 3, 1),  # 高校
        context="math_competition_winner",
        observed_outcome="regional_prize",
        implicated_dimensions={CognitiveDimension.ANALOGICAL_TRANSFER, CognitiveDimension.PROCESSING_SPEED},
        direction="strength",
        severity=1.5,
        reliability=0.7
    )
]

generator = SituatedPositionGenerator(estimator, mapper)
situated = generator.generate(observations)

prompt = create_persona_prompt(situated, debate_topic="産業革命の原因について")
print(prompt)

# 知識的位置と能力プロファイル

## 背景（推定された発達経緯）
初期の能力パターンは「rote_heavy_causal_weak」型で、2015年頃の観測において暗記力は-0.8、因果推論は-2.0だった。2018年頃、「rote_heavy_causal_weak」から「deep_slow_thinker」へと能力パターンが転換した跡がある。現在は「deep_slow_thinker」型と推定され（確信度0.72）、このパターンに典型的な知識構造と推論特性を持つ。

## 現在の知識境界
- 確実に掌握: deep_structures, cross_domain_patterns, methodology_epistemology...
- 限界・不安定: quick_fact_recall, rapid_assessment, trivia_knowledge...
- 重点領域: theoretical_frameworks, paradigm_analysis

## 認知的処理特性
- 応答速度: slow
- 説明スタイル: step_by_step
- 誤りパターン: confused
- 学習戦略: understanding_first
- 知識編成: hierarchical

## 議論における制約
以下の特性に従って発言してください：
1. 因果推論の複雑さは「多変量相互作用を含む」に制限
2. 反論時には「step_by_step」で説明を試みる
3. 不確実な知識に触れる際は「条件付き表明」を使用

## 議論テーマ: 産業革命の原因について
上記の知識位置と能力プロファイルから、自然な発言を生成してください。

┌─────────────────────────────────────────────────────────────┐
│                    コンパイル入力層                           │
├─────────────────────────────────────────────────────────────┤
│  [観点1] KnowledgePoset        [観点2] Observations          │
│  ・知識間の半順序関係           ・中学歴史:赤点(15歳)         │
│  ・ドメインタグ付与            ・数学競技:入賞(17歳)         │
│                               ・大学院進学(22歳)            │
├─────────────────────────────────────────────────────────────┤
│  [観点3] PersonaSignatures                                  │
│  ・(GREETING, EMPATHIZE, WARM)                              │
│  ・(CONFRONTATION, ANALYZE, DIRECT)                          │
│  ・(QUESTION, DEFLECT, EVASIVE) ...                         │
└─────────────────────────────────────────────────────────────┘
                              ↓
┌─────────────────────────────────────────────────────────────┐
│                    統合コンパイルエンジン                     │
├─────────────────────────────────────────────────────────────┤
│  Step 1: 能力分布推定 → ステレオタイプ連想 → 知識位置候補    │
│  Step 2: 半順序上での位置精緻化（候補の検証・調整）          │
│  Step 3: ペルソナと知識位置の整合性チェック                  │
│  Step 4: 25歳時点の統合プロフィール生成                      │
└─────────────────────────────────────────────────────────────┘
                              ↓
┌─────────────────────────────────────────────────────────────┐
│                25歳コンパイル済みプロフィール                 │
│              CompiledProfile@Age(25)                        │
├─────────────────────────────────────────────────────────────┤
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐          │
│  │ 知識位置     │  │ 能力・経緯   │  │ 振る舞い様式 │          │
│  │ (Poset上)   │  │ (分布+物語)  │  │ (ペルソナ)   │          │
│  └─────────────┘  └─────────────┘  └─────────────┘          │
│         ↓                ↓                ↓                 │
│  ・lower_boundary    ・現在の分布      ・response_rules       │
│  ・upper_boundary    ・成長軌道        ・speech_patterns      │
│  ・incomparable_set  ・転換点          ・argumentation_style  │
│  ・expertise_focus   ・信頼区間        ・vulnerability_map    │
└─────────────────────────────────────────────────────────────┘

from dataclasses import dataclass, field
from typing import Dict, List, Set, Tuple, Optional, Any
from datetime import datetime, timedelta
from enum import Enum
import numpy as np

# ============================================
# 3観点のデータ構造（前回定義の統合）
# ============================================

@dataclass(frozen=True)
class KnowledgeAtom:
    id: str
    content: str
    prerequisites: frozenset = frozenset()
    generalizes: frozenset = frozenset()
    instantiates: frozenset = frozenset()
    domain_tags: frozenset = frozenset()
    complexity_score: float = 1.0

class CognitiveDimension(Enum):
    ROTE_MEMORY = "rote_memory"
    CAUSAL_INFERENCE = "causal"
    ANALOGICAL_TRANSFER = "analogical"
    PROCESSING_SPEED = "speed"
    METACOGNITION = "metacognition"
    # ... 他

@dataclass
class AbilityProfile:
    timestamp: datetime
    means: Dict[CognitiveDimension, float]
    variances: Dict[CognitiveDimension, float]
    confidence: Dict[CognitiveDimension, float]

@dataclass
class HistoricalObservation:
    timestamp: datetime
    context: str
    observed_outcome: str
    implicated_dimensions: Set[CognitiveDimension]
    severity: float
    reliability: float

@dataclass
class ResponseSignature:
    input_pattern: str
    cognitive_mode: str
    output_style: str

# ============================================
# 統合コンパイル済みプロフィール
# ============================================

@dataclass
class CompiledProfile:
    """
    25歳時点の完全なエージェントプロフィール
    3観点が統合された状態
    """
    age: int = 25
    compilation_timestamp: datetime = field(default_factory=datetime.now)
    
    # --- 観点1: 知識位置（半順序上） ---
    knowledge_position: Dict[str, Any] = field(default_factory=dict)
    # 内容:
    # - "lower_boundary": Set[str]  # 確実に掌握
    # - "upper_boundary": Set[str]  # 限界・不安定
    # - "incomparable_neighbors": Set[str]  # 非可比な隣接知識
    # - "height_in_poset": int  # 深さ
    # - "width_at_level": int    # 広がり
    
    # --- 観点2: 能力分布と発達経緯 ---
    ability_profile: AbilityProfile = field(default=None)
    developmental_trajectory: List[Tuple[datetime, str, Dict]] = field(default_factory=list)
    # 各要素: (timestamp, stereotype_label, position_snapshot)
    key_transitions: List[Dict] = field(default_factory=list)
    # 転換点の詳細
    
    # --- 観点3: ペルソナ（振る舞い様式） ---
    persona_rules: List[ResponseSignature] = field(default_factory=list)
    behavioral_constraints: Dict[str, Any] = field(default_factory=dict)
    # 内容:
    # - "response_latency": str
    # - "explanation_style": str
    # - "argumentation_tendency": str
    # - "knowledge_gaps_expression": str  # 不知をどう表現するか
    
    # --- 統合層: 3観点の相互作用 ---
    knowledge_persona_interaction: Dict[str, Any] = field(default_factory=dict)
    # 内容:
    # - "how_knowledge_affects_style": Dict  # 知識が豊富な領域 vs 貧弱な領域での振る舞い違い
    # - "style_affects_knowledge_access": Dict  # ペルソナが知識検索・表現に与える影響
    
    # --- 出力用: 生成された物語 ---
    narrative_backstory: str = ""
    prompt_template: str = ""

# ============================================
# 統合コンパイラ本体
# ============================================

class ProfileCompiler:
    """
    3観点を統合して25歳プロフィールをコンパイル
    """
    
    def __init__(self, 
                 poset: "KnowledgePoset",  # 観点1
                 stereotype_mapper: "StereotypeMapper",  # 観点2
                 persona_selector: "PersonaSelector"):  # 観点3
        self.poset = poset
        self.mapper = stereotype_mapper
        self.persona_selector = persona_selector
        
        # 年齢スケール定義
        self.age_reference = {
            "junior_high": 15,
            "high_school": 17,
            "undergraduate": 21,
            "graduate": 25
        }
    
    def compile(self,
                observations: List[HistoricalObservation],
                target_age: int = 25,
                base_persona_tags: Optional[List[ResponseSignature]] = None) -> CompiledProfile:
        """
        3観点を統合コンパイル
        """
        
        # Step 1: 観点2 → 能力分布とステレオタイプ
        current_date = datetime.now()
        birth_year = current_date.year - target_age
        
        ability_profile, trajectory = self._estimate_trajectory(
            observations, 
            target_age=target_age,
            birth_year=birth_year
        )
        
        # Step 2: ステレオタイプ → 知識位置候補（観点1との接続）
        years_elapsed = target_age - self._estimate_age_at_first_obs(observations)
        stereotype_matches = self.mapper.map_profile_to_position(
            ability_profile, 
            years_elapsed
        )
        best_stereotype = stereotype_matches[0]
        
        # Step 3: 半順序上での位置精緻化
        knowledge_pos = self._refine_knowledge_position(
            best_stereotype[2],  # position_spec
            ability_profile,
            target_age
        )
        
        # Step 4: 観点3（ペルソナ）の統合
        persona = self._integrate_persona(
            base_persona_tags or [],
            ability_profile,
            knowledge_pos,
            best_stereotype[0]  # stereotype_label
        )
        
        # Step 5: 相互作用層の構築
        interaction = self._compute_interactions(knowledge_pos, persona, ability_profile)
        
        # Step 6: 物語生成
        narrative = self._generate_narrative(
            trajectory, 
            knowledge_pos, 
            persona, 
            target_age
        )
        
        prompt = self._generate_prompt_template(
            knowledge_pos, 
            ability_profile, 
            persona, 
            interaction,
            narrative
        )
        
        return CompiledProfile(
            age=target_age,
            knowledge_position=knowledge_pos,
            ability_profile=ability_profile,
            developmental_trajectory=trajectory,
            key_transitions=self._extract_transitions(trajectory),
            persona_rules=persona["rules"],
            behavioral_constraints=persona["constraints"],
            knowledge_persona_interaction=interaction,
            narrative_backstory=narrative,
            prompt_template=prompt
        )
    
    def _estimate_trajectory(self,
                            observations: List[HistoricalObservation],
                            target_age: int,
                            birth_year: int) -> Tuple[AbilityProfile, List]:
        """観点2: 時系列能力分布の推定"""
        # 観測を時系列で処理
        sorted_obs = sorted(observations, key=lambda x: x.timestamp)
        
        trajectory = []
        current_profile = None
        
        for obs in sorted_obs:
            obs_age = obs.timestamp.year - birth_year
            
            # ベイズ更新（簡易版）
            if current_profile is None:
                current_profile = self._initialize_profile(obs)
            else:
                current_profile = self._update_profile(current_profile, obs)
            
            # ステレオタイプ判定
            matches = self.mapper.map_profile_to_position(current_profile, 0)
            stereotype = matches[0][0] if matches else "unknown"
            
            trajectory.append({
                "age": obs_age,
                "timestamp": obs.timestamp,
                "profile": current_profile,
                "stereotype": stereotype,
                "trigger_observation": obs
            })
        
        # 現在（25歳）までの成長を予測
        final_profile = self._project_to_age(current_profile, target_age, trajectory)
        
        return final_profile, trajectory
    
    def _refine_knowledge_position(self,
                                   stereotype_position: Dict,
                                   ability_profile: AbilityProfile,
                                   age: int) -> Dict:
        """観点1: ステレオタイプ位置を半順序上で精緻化"""
        
        # ステレオタイプから初期位置を取得
        lower = set(stereotype_position.get("lower_boundary", []))
        upper = set(stereotype_position.get("upper_boundary", []))
        
        # 能力分布による調整
        means = ability_profile.means
        
        # 因果推論が強い → 抽象度の高い知識をlowerに追加
        if means.get(CognitiveDimension.CAUSAL_INFERENCE, 0) > 1.0:
            abstract_knowledge = self._find_abstract_knowledge(lower)
            lower.update(abstract_knowledge)
        
        # 処理速度が遅い → 即応性要求される知識をupperに
        if means.get(CognitiveDimension.PROCESSING_SPEED, 0) < -0.5:
            quick_recall_knowledge = self._find_quick_recall_knowledge(lower)
            upper.update(quick_recall_knowledge)
        
        # 半順序の整合性チェック
        lower, upper = self._ensure_poset_consistency(lower, upper)
        
        # 非可比な隣接知識を特定
        incomparable = self._find_incomparable_neighbors(lower, upper)
        
        # 年齢による「見せかけの知識」（社会的に持っているべきだが実は不安定）
        social_mask = self._compute_social_mask(age, lower, upper)
        
        return {
            "lower_boundary": lower,  # 本当に掌握
            "upper_boundary": upper,  # 限界
            "social_mask": social_mask,  # 社会的に装う知識
            "incomparable_neighbors": incomparable,
            "height_in_poset": self.poset.height(list(lower)[0]) if lower else 0,
            "expertise_focus": stereotype_position.get("focus_domains", set()),
            "knowledge_organization": self._infer_organization(ability_profile)
        }
    
    def _integrate_persona(self,
                           base_tags: List[ResponseSignature],
                           ability_profile: AbilityProfile,
                           knowledge_pos: Dict,
                           stereotype_label: str) -> Dict:
        """観点3: ペルソナの統合"""
        
        # 能力分布から派生する制約
        derived_constraints = self._derive_constraints(ability_profile)
        
        # 知識位置から派生する制約
        knowledge_constraints = self._derive_knowledge_constraints(knowledge_pos)
        
        # 基本タグを調整
        adjusted_rules = []
        for tag in base_tags:
            adjusted = self._adjust_tag_by_profile(tag, ability_profile, knowledge_pos)
            adjusted_rules.append(adjusted)
        
        # 知識ギャップに関する特別なルールを追加
        gap_rules = self._generate_gap_rules(knowledge_pos)
        
        return {
            "rules": adjusted_rules + gap_rules,
            "constraints": {**derived_constraints, **knowledge_constraints},
            "base_stereotype": stereotype_label,
            "adaptation_notes": self._generate_adaptation_notes(ability_profile, knowledge_pos)
        }
    
    def _compute_interactions(self,
                              knowledge_pos: Dict,
                              persona: Dict,
                              ability_profile: AbilityProfile) -> Dict:
        """統合層: 3観点の相互作用"""
        
        return {
            "how_knowledge_affects_style": {
                "expert_domains": {
                    "style": "assertive_direct",
                    "latency": "normal",
                    "explanation": "can_use_jargon"
                },
                "boundary_domains": {
                    "style": "hesitant_exploratory",
                    "latency": "slow",
                    "explanation": "must_use_analogy"
                },
                "masked_domains": {
                    "style": "confident_but_vague",
                    "latency": "fast_but_shallow",
                    "explanation": "uses_authority_heuristics"
                }
            },
            "style_affects_knowledge_access": {
                "high_metacognition": "can_recognize_own_gaps",
                "low_metacognition": "blind_spots_remain_invisible",
                "defensive_persona": "resists_knowledge_updates",
                "curious_persona": "actively_seeks_upper_boundary"
            },
            "developmental_coupling": {
                "ability_to_knowledge": "causal_inference_enables_abstract_knowledge",
                "knowledge_to_ability": "expertise_breeds_metacognition",
                "persona_to_ability": "argumentative_style_exercises_reasoning"
            }
        }
    
    def _generate_narrative(self,
                            trajectory: List[Dict],
                            knowledge_pos: Dict,
                            persona: Dict,
                            age: int) -> str:
        """統合された背景物語を生成"""
        
        parts = []
        
        # 発達の要約
        if trajectory:
            first = trajectory[0]
            last = trajectory[-1]
            parts.append(
                f"{first['age']}歳時点では「{first['stereotype']}」型で、"
                f"特に{CognitiveDimension.ROTE_MEMORY}と{CognitiveDimension.CAUSAL_INFERENCE}に"
                f"顕著な偏りがあった。"
            )
            
            if len(trajectory) > 1:
                parts.append(
                    f"その後、{last['age']}歳頃に「{last['stereotype']}」へと転換し、"
                    f"現在{age}歳では深い構造理解と横断的類推を強みとする。"
                )
        
        # 知識位置の描写
        parts.append(
            f"知識構造は「{knowledge_pos['knowledge_organization']}」型で、"
            f"{len(knowledge_pos['lower_boundary'])}個の基盤知識を確実に掌握し、"
            f"{len(knowledge_pos['upper_boundary'])}個の領域で限界を持つ。"
        )
        
        # ペルソナの統合
        constraints = persona["constraints"]
        parts.append(
            f"議論では{constraints.get('response_latency', '標準的')}な応答で、"
            f"{constraints.get('explanation_style', '直感的')}な説明を試みるが、"
            f"知識境界では{constraints.get('uncertainty_expression', '婉曲的')}に振る舞う。"
        )
        
        return " ".join(parts)
    
    def _generate_prompt_template(self,
                                  knowledge_pos: Dict,
                                  ability_profile: AbilityProfile,
                                  persona: Dict,
                                  interaction: Dict,
                                  narrative: str) -> str:
        """最終的なLLMプロンプトテンプレート"""
        
        return f"""# コンパイル済みエージェントプロフィール（{self.age}歳）

## 背景物語
{narrative}

## 知識的立場（半順序上の位置）
- 確実領域（lower boundary）: {', '.join(list(knowledge_pos['lower_boundary'])[:5])}...
- 限界領域（upper boundary）: {', '.join(list(knowledge_pos['upper_boundary'])[:3])}...
- 社会的装知（social mask）: {', '.join(list(knowledge_pos['social_mask'])[:3])}...
- 非可比隣接: {len(knowledge_pos['incomparable_neighbors'])}個の別系列専門知識と隣接
- 編成様式: {knowledge_pos['knowledge_organization']}

## 認知特性（能力分布の現在値）
{self._format_ability_profile(ability_profile)}

## 振る舞い制約（ペルソナ）
{self._format_persona_rules(persona['rules'])}

## 知識-ペルソナ相互作用
- 得意領域での振る舞い: {interaction['how_knowledge_affects_style']['expert_domains']['style']}
- 境界領域での振る舞い: {interaction['how_knowledge_affects_style']['boundary_domains']['style']}
- 装知領域での振る舞い: {interaction['how_knowledge_affects_style']['masked_domains']['style']}

## 議論指示
上記のプロフィールに従い、自然な発言を生成してください。
特に、知識境界に触れる際は「{persona['constraints'].get('uncertainty_expression', '不確実性を明示')}」し、
能力特性に応じた「{persona['constraints'].get('explanation_style', '説明スタイル')}」を使用してください。
"""
    
    # --- ヘルパーメソッド（省略実装） ---
    def _estimate_age_at_first_obs(self, observations: List[HistoricalObservation]) -> int:
        if not observations:
            return 15
        # 簡易推定
        return 15
    
    def _initialize_profile(self, obs: HistoricalObservation) -> AbilityProfile:
        # 簡易初期化
        return AbilityProfile(
            timestamp=obs.timestamp,
            means={d: obs.severity if d in obs.implicated_dimensions else 0.0 
                   for d in CognitiveDimension},
            variances={d: 1.0 for d in CognitiveDimension},
            confidence={d: obs.reliability if d in obs.implicated_dimensions else 0.5 
                       for d in CognitiveDimension}
        )
    
    def _update_profile(self, current: AbilityProfile, obs: HistoricalObservation) -> AbilityProfile:
        # 簡易ベイズ更新
        return current  # 省略
    
    def _project_to_age(self, profile: AbilityProfile, target_age: int, trajectory: List) -> AbilityProfile:
        # 成長予測
        return profile  # 省略
    
    def _find_abstract_knowledge(self, lower_set: Set[str]) -> Set[str]:
        # 抽象度の高い知識を検索
        return set()
    
    def _find_quick_recall_knowledge(self, lower_set: Set[str]) -> Set[str]:
        # 即応性を要求される知識を検索
        return set()
    
    def _ensure_poset_consistency(self, lower: Set[str], upper: Set[str]) -> Tuple[Set[str], Set[str]]:
        # 半順序の整合性を確保
        return lower, upper
    
    def _find_incomparable_neighbors(self, lower: Set[str], upper: Set[str]) -> Set[str]:
        # 非可比隣接を検出
        return set()
    
    def _compute_social_mask(self, age: int, lower: Set[str], upper: Set[str]) -> Set[str]:
        # 年齢に応じた社会的装知を計算
        # 例: 25歳の大学院生は「博士課程レベルの知識」を装うべきだが...
        expected = set()  # 年齢に期待される知識
        actual = lower  # 実際の掌握
        return expected - actual  # 装うべき知識
    
    def _infer_organization(self, profile: AbilityProfile) -> str:
        # 知識編成様式を推定
        if profile.means.get(CognitiveDimension.ANALOGICAL_TRANSFER, 0) > 0.5:
            return "hierarchical_network"
        if profile.means.get(CognitiveDimension.ROTE_MEMORY, 0) > profile.means.get(CognitiveDimension.CAUSAL_INFERENCE, 0):
            return "linear_chronological"
        return "clustered_by_domain"
    
    def _derive_constraints(self, profile: AbilityProfile) -> Dict[str, Any]:
        means = profile.means
        return {
            "response_latency": "slow" if means.get(CognitiveDimension.PROCESSING_SPEED, 0) < -0.5 else "normal",
            "explanation_style": "step_by_step" if means.get(CognitiveDimension.METACOGNITION, 0) > 0.5 else "intuitive",
            "uncertainty_expression": "explicit_probability" if means.get(CognitiveDimension.METACOGNITION, 0) > 0.8 else "hedging_language"
        }
    
    def _derive_knowledge_constraints(self, knowledge_pos: Dict) -> Dict[str, Any]:
        return {
            "expertise_domains": knowledge_pos.get("expertise_focus", set()),
            "can_use_jargon_in": knowledge_pos.get("lower_boundary", set()),
            "must_avoid_in": knowledge_pos.get("upper_boundary", set())
        }
    
    def _adjust_tag_by_profile(self, 
                                tag: ResponseSignature,
                                profile: AbilityProfile,
                                knowledge_pos: Dict) -> ResponseSignature:
        # タグを能力・知識に応じて調整
        return tag  # 省略
    
    def _generate_gap_rules(self, knowledge_pos: Dict) -> List[ResponseSignature]:
        # 知識ギャップに関する特別ルール
        return []
    
    def _generate_adaptation_notes(self, 
                                    profile: AbilityProfile,
                                    knowledge_pos: Dict) -> List[str]:
        return []
    
    def _extract_transitions(self, trajectory: List[Dict]) -> List[Dict]:
        # 転換点を抽出
        transitions = []
        prev = None
        for t in trajectory:
            if prev and t["stereotype"] != prev["stereotype"]:
                transitions.append({
                    "age": t["age"],
                    "from": prev["stereotype"],
                    "to": t["stereotype"],
                    "trigger": t["trigger_observation"].context
                })
            prev = t
        return transitions
    
    def _format_ability_profile(self, profile: AbilityProfile) -> str:
        lines = []
        for dim, val in sorted(profile.means.items(), key=lambda x: x[1], reverse=True):
            conf = profile.confidence.get(dim, 0.5)
            lines.append(f"- {dim.value}: {val:.2f} (信頼度: {conf:.2f})")
        return "\n".join(lines)
    
    def _format_persona_rules(self, rules: List[ResponseSignature]) -> str:
        return "\n".join([f"- {r.input_pattern} → {r.cognitive_mode} → {r.output_style}" for r in rules])