def __init__(self):
    self.axioms_verified = {}

def efficiency_axiom(self, payoff_function: Callable, features: List[str]) -> bool:
    """
    效率公理：所有特徵的Shapley值之和等於總價值
    v(N) = Σ φ_i(v)
    """
    total_value = payoff_function(features)
    shapley_values = self.compute_shapley_values(payoff_function, features)
    shapley_sum = sum(shapley_values.values())
    
    is_satisfied = np.isclose(total_value, shapley_sum, rtol=1e-10)
    self.axioms_verified['efficiency'] = is_satisfied
    return is_satisfied

def symmetry_axiom(self, payoff_function: Callable, features: List[str]) -> bool:
    """
    對稱公理：對價值函數有相同貢獻的特徵應獲得相同分配
    """
    # 測試對稱特徵
    symmetric_features = ['feature1', 'feature2']
    if all(f in features for f in symmetric_features):
        # 創建對稱的價值函數
        def symmetric_payoff(subset):
            count = sum(1 for f in symmetric_features if f in subset)
            base_value = payoff_function([f for f in subset if f not in symmetric_features])
            return base_value + count * 10  # 對稱貢獻
        
        shapley_values = self.compute_shapley_values(symmetric_payoff, features)
        values = [shapley_values[f] for f in symmetric_features]
        is_satisfied = np.isclose(values[0], values[1], rtol=1e-10)
        self.axioms_verified['symmetry'] = is_satisfied
        return is_satisfied
    return True

def dummy_axiom(self, payoff_function: Callable, features: List[str]) -> bool:
    """
    虛擬公理：對任何聯盟都沒有貢獻的特徵應獲得零分配
    """
    dummy_feature = 'dummy_feature'
    if dummy_feature not in features:
        features.append(dummy_feature)
    
    def dummy_payoff(subset):
        if dummy_feature in subset:
            return payoff_function([f for f in subset if f != dummy_feature])
        return payoff_function(subset)
    
    shapley_values = self.compute_shapley_values(dummy_payoff, features)
    is_satisfied = np.isclose(shapley_values[dummy_feature], 0, atol=1e-10)
    self.axioms_verified['dummy'] = is_satisfied
    return is_satisfied

def additivity_axiom(self, payoff_function1: Callable, payoff_function2: Callable, 
                    features: List[str]) -> bool:
    """
    可加性公理：兩個獨立博弈的Shapley值等於各自Shapley值之和
    φ_i(v + w) = φ_i(v) + φ_i(w)
    """
    def combined_payoff(subset):
        return payoff_function1(subset) + payoff_function2(subset)
    
    shapley_combined = self.compute_shapley_values(combined_payoff, features)
    shapley1 = self.compute_shapley_values(payoff_function1, features)
    shapley2 = self.compute_shapley_values(payoff_function2, features)
    
    is_satisfied = all(
        np.isclose(shapley_combined[f], shapley1[f] + shapley2[f], rtol=1e-10)
        for f in features
    )
    self.axioms_verified['additivity'] = is_satisfied
    return is_satisfied

def compute_shapley_values(self, payoff_function: Callable, features: List[str]) -> Dict[str, float]:
    """計算Shapley值"""
    n = len(features)
    shapley_values = {feature: 0 for feature in features}
    
    for feature in features:
        for subset_size in range(n):
            # 計算權重因子
            weight = factorial(subset_size) * factorial(n - subset_size - 1) / factorial(n)
            
            # 考慮所有不包含當前特徵的子集
            other_features = [f for f in features if f != feature]
            for subset in itertools.combinations(other_features, subset_size):
                subset_without = list(subset)
                subset_with = subset_without + [feature]
                
                marginal_contribution = (payoff_function(subset_with) - 
                                       payoff_function(subset_without))
                shapley_values[feature] += weight * marginal_contribution
    
    return shapley_values

def __init__(self):
    self.interaction_axioms = {}

def compute_shapley_interaction(self, payoff_function: Callable, 
                              features: List[str], subset: List[str]) -> float:
    """
    計算Shapley交互指數
    I_Shapley(S) = Σ_{T ⊆ N\S} w_{|T|}(v(T ∪ S) - Σ_{i∈S} v(T ∪ {i}) + Σ_{i<j∈S} v(T ∪ {i,j}) - ...)
    """
    n = len(features)
    s = len(subset)
    interaction = 0
    
    remaining_features = [f for f in features if f not in subset]
    
    for t_size in range(len(remaining_features) + 1):
        for t_subset in itertools.combinations(remaining_features, t_size):
            t_list = list(t_subset)
            
            # 計算Möbius反演
            mobius_sum = 0
            for k in range(s + 1):
                for u_subset in itertools.combinations(subset, k):
                    sign = (-1) ** (s - k)
                    mobius_sum += sign * payoff_function(t_list + list(u_subset))
            
            # 權重計算
            weight = factorial(t_size) * factorial(n - t_size - s) / factorial(n - s + 1)
            interaction += weight * mobius_sum
    
    return interaction

def linearity_axiom(self, payoff1: Callable, payoff2: Callable, 
                   features: List[str], subset: List[str]) -> bool:
    """
    線性公理：I(v + w) = I(v) + I(w)
    """
    def combined_payoff(s):
        return payoff1(s) + payoff2(s)
    
    I_combined = self.compute_shapley_interaction(combined_payoff, features, subset)
    I1 = self.compute_shapley_interaction(payoff1, features, subset)
    I2 = self.compute_shapley_interaction(payoff2, features, subset)
    
    is_satisfied = np.isclose(I_combined, I1 + I2, rtol=1e-10)
    self.interaction_axioms['linearity'] = is_satisfied
    return is_satisfied

def dummy_axiom_interaction(self, payoff_function: Callable, 
                          features: List[str], subset: List[str]) -> bool:
    """
    交互虛擬公理：如果特徵對交互無貢獻，則交互指數為零
    """
    # 添加虛擬特徵
    dummy = 'dummy_feature'
    if dummy not in features:
        features_extended = features + [dummy]
    else:
        features_extended = features.copy()
    
    def dummy_payoff(s):
        # 虛擬特徵不參與任何交互
        if dummy in s:
            return payoff_function([f for f in s if f != dummy])
        return payoff_function(s)
    
    # 測試包含虛擬特徵的交互
    test_subset = subset + [dummy] if subset else [dummy]
    interaction = self.compute_shapley_interaction(dummy_payoff, features_extended, test_subset)
    
    is_satisfied = np.isclose(interaction, 0, atol=1e-10)
    self.interaction_axioms['dummy_interaction'] = is_satisfied
    return is_satisfied

def symmetry_axiom_interaction(self, payoff_function: Callable, 
                             features: List[str]) -> bool:
    """
    交互對稱公理：對稱特徵應具有相同的交互模式
    """
    symmetric_pairs = [('feature1', 'feature2'), ('feature2', 'feature3')]
    
    for feat1, feat2 in symmetric_pairs:
        if feat1 in features and feat2 in features:
            # 單個特徵的交互
            I1_single = self.compute_shapley_interaction(payoff_function, features, [feat1])
            I2_single = self.compute_shapley_interaction(payoff_function, features, [feat2])
            
            # 配對交互
            I_pair1 = self.compute_shapley_interaction(payoff_function, features, [feat1, feat2])
            
            is_satisfied = (np.isclose(I1_single, I2_single, rtol=1e-10) and 
                           not np.isclose(I_pair1, 0, atol=1e-10))
            self.interaction_axioms[f'symmetry_{feat1}_{feat2}'] = is_satisfied
    
    return True

# 交互項
interaction_terms = 0
if 'feature1' in subset and 'feature2' in subset:
    interaction_terms += 5  # 正交互
if 'feature1' in subset and 'feature3' in subset:
    interaction_terms -= 3  # 負交互

return base + linear_terms + interaction_terms

def __init__(self):
    self.conflicts = {}

def analyze_efficiency_conflict(self, payoff_function: Callable, features: List[str]):
    """
    分析效率公理與交互分解的衝突
    """
    print("=== 效率公理衝突分析 ===")
    
    # 計算Shapley值
    shapley_calc = AxiomaticShapley()
    shapley_values = shapley_calc.compute_shapley_values(payoff_function, features)
    total_shapley = sum(shapley_values.values())
    total_value = payoff_function(features)
    
    print(f"總價值: {total_value}")
    print(f"Shapley值之和: {total_shapley}")
    print(f"效率公理滿足: {np.isclose(total_value, total_shapley, rtol=1e-10)}")
    
    # 交互分解
    interaction_calc = InteractionIndex()
    interaction_decomposition = {}
    
    # 計算所有單個特徵和交互效應
    for r in range(1, len(features) + 1):
        for subset in itertools.combinations(features, r):
            interaction = interaction_calc.compute_shapley_interaction(
                payoff_function, features, list(subset)
            )
            interaction_decomposition[tuple(subset)] = interaction
            print(f"交互 {subset}: {interaction:.6f}")
    
    # 驗證交互分解的完整性
    reconstruction = sum(interaction_decomposition.values())
    print(f"交互分解重建: {reconstruction}")
    print(f"分解完整性: {np.isclose(total_value, reconstruction, rtol=1e-10)}")
    
    # 分析衝突
    conflict_strength = abs(total_shapley - reconstruction)
    self.conflicts['efficiency_vs_decomposition'] = {
        'shapley_sum': total_shapley,
        'decomposition_sum': reconstruction,
        'conflict_magnitude': conflict_strength,
        'has_conflict': conflict_strength > 1e-10
    }
    
    return self.conflicts

def analyze_additivity_conflict(self, payoff_functions: List[Callable], features: List[str]):
    """
    分析可加性公理在交互場景下的衝突
    """
    print("\n=== 可加性公理衝突分析 ===")
    
    interaction_calc = InteractionIndex()
    subset = ['feature1', 'feature2']
    
    # 計算單個函數的交互
    individual_interactions = []
    for i, payoff_func in enumerate(payoff_functions):
        interaction = interaction_calc.compute_shapley_interaction(
            payoff_func, features, subset
        )
        individual_interactions.append(interaction)
        print(f"函數{i+1}的交互 {subset}: {interaction:.6f}")
    
    # 計算組合函數的交互
    def combined_payoff(s):
        return sum(f(s) for f in payoff_functions)
    
    combined_interaction = interaction_calc.compute_shapley_interaction(
        combined_payoff, features, subset
    )
    sum_individual = sum(individual_interactions)
    
    print(f"組合函數交互: {combined_interaction:.6f}")
    print(f"單個交互之和: {sum_individual:.6f}")
    print(f"可加性滿足: {np.isclose(combined_interaction, sum_individual, rtol=1e-10)}")
    
    conflict_strength = abs(combined_interaction - sum_individual)
    self.conflicts['additivity_vs_interaction'] = {
        'combined_interaction': combined_interaction,
        'sum_individual': sum_individual,
        'conflict_magnitude': conflict_strength,
        'has_conflict': conflict_strength > 1e-10
    }
    
    return self.conflicts

# 強交互場景
if {'feature1', 'feature2', 'feature3'}.issubset(features_in_subset):
    return 20  # 三特徵強協同
elif {'feature1', 'feature2'}.issubset(features_in_subset):
    return 15  # 雙特徵協同
elif 'feature1' in features_in_subset:
    return 8   # 單個特徵
elif 'feature2' in features_in_subset:
    return 7
elif 'feature3' in features_in_subset:
    return 6
else:
    return 5   # 基準值

def __init__(self):
    self.x1, self.x2, self.x3 = symbols('x1 x2 x3')

def analyze_non_separable_function(self):
    """
    分析不可分函數的交互效應
    """
    print("=== 數學不可分性分析 ===")
    
    # 定義不可分函數
    f = self.x1 * self.x2 * self.x3 + self.x1**2 * self.x2 - 2 * self.x1 * self.x3**2
    print(f"原函數: {f}")
    
    # 嘗試線性分解
    linear_approx = self.x1 + self.x2 + self.x3
    print(f"線性近似: {linear_approx}")
    
    # 計算誤差
    error = f - linear_approx
    print(f"分解誤差: {error}")
    
    # 分析交互項
    interaction_terms = []
    for term in f.as_ordered_terms():
        if len(term.free_symbols) > 1:
            interaction_terms.append(term)
    
    print(f"交互項: {sum(interaction_terms)}")
    
    return f, linear_approx, error

def shapley_decomposition_attempt(self, payoff_function, features):
    """
    嘗試對不可分函數進行Shapley分解
    """
    print("\n=== Shapley分解嘗試 ===")
    
    shapley_calc = AxiomaticShapley()
    interaction_calc = InteractionIndex()
    
    # 計算Shapley值
    shapley_values = shapley_calc.compute_shapley_values(payoff_function, features)
    
    # 計算各階交互
    interactions = {}
    for order in range(1, len(features) + 1):
        for subset in itertools.combinations(features, order):
            interaction = interaction_calc.compute_shapley_interaction(
                payoff_function, features, list(subset)
            )
            interactions[subset] = interaction
    
    # 驗證分解完整性
    total_from_interactions = sum(interactions.values())
    total_value = payoff_function(features)
    
    print(f"真實總價值: {total_value}")
    print(f"交互分解重建: {total_from_interactions}")
    print(f"Shapley值之和: {sum(shapley_values.values())}")
    
    # 分析不可分性指標
    indivisibility_index = abs(total_value - total_from_interactions) / abs(total_value)
    print(f"不可分性指數: {indivisibility_index:.6f}")
    
    return indivisibility_index, interactions, shapley_values

if 'x1' in subset and 'x2' in subset and 'x3' in subset:
    value += x_vals['x1'] * x_vals['x2'] * x_vals['x3']
if 'x1' in subset and 'x2' in subset:
    value += x_vals['x1']**2 * x_vals['x2']
if 'x1' in subset and 'x3' in subset:
    value -= 2 * x_vals['x1'] * x_vals['x3']**2

return value

def __init__(self):
    self.conflict_cases = []

def analyze_rf_model_conflicts(self, X, y, feature_names):
    """
    分析隨機森林模型的解釋衝突
    """
    print("=== 隨機森林模型解釋衝突分析 ===")
    
    # 訓練模型
    model = RandomForestRegressor(n_estimators=100, random_state=42)
    model.fit(X, y)
    
    # 計算特徵重要性
    feature_importance = model.feature_importances_
    
    # 模擬Shapley值計算（簡化版）
    shapley_approx = self.approximate_shapley_values(model, X, feature_names)
    
    # 計算交互效應
    interactions = self.estimate_interactions(model, X, feature_names)
    
    # 分析衝突
    conflicts = self.detect_explanation_conflicts(feature_importance, shapley_approx, interactions)
    
    return conflicts, feature_importance, shapley_approx, interactions

def approximate_shapley_values(self, model, X, feature_names, n_samples=1000):
    """近似計算Shapley值"""
    shapley_values = {f: 0 for f in feature_names}
    n_features = len(feature_names)
    
    for _ in range(n_samples):
        # 隨機選擇樣本
        sample_idx = np.random.randint(0, len(X))
        x_sample = X[sample_idx]
        
        # 隨機排列特徵
        permutation = np.random.permutation(n_features)
        
        for j, feature_idx in enumerate(permutation):
            # 創建包含前j個特徵的子集
            subset_without = x_sample.copy()
            subset_without[permutation[j:]] = 0  # 簡化：將未選特徵設為零
            
            subset_with = x_sample.copy()
            subset_with[permutation[j+1:]] = 0
            
            # 計算邊際貢獻
            pred_without = model.predict([subset_without])[0]
            pred_with = model.predict([subset_with])[0]
            
            feature_name = feature_names[feature_idx]
            shapley_values[feature_name] += (pred_with - pred_without) / n_samples
    
    return shapley_values

def estimate_interactions(self, model, X, feature_names, n_pairs=50):
    """估計特徵交互效應"""
    interactions = {}
    
    # 分析特徵對
    for i, feat1 in enumerate(feature_names):
        for j, feat2 in enumerate(feature_names[i+1:], i+1):
            # 使用部分依賴圖估計交互
            pdp_feat1 = partial_dependence(model, X, [i], grid_resolution=10)
            pdp_feat2 = partial_dependence(model, X, [j], grid_resolution=10)
            pdp_both = partial_dependence(model, X, [i, j], grid_resolution=10)
            
            # 計算交互強度（簡化）
            interaction_strength = np.std(pdp_both['average']) - 0.5 * (
                np.std(pdp_feat1['average']) + np.std(pdp_feat2['average'])
            )
            
            interactions[(feat1, feat2)] = interaction_strength
    
    return interactions

def detect_explanation_conflicts(self, feature_importance, shapley_values, interactions):
    """檢測解釋衝突"""
    conflicts = []
    
    # 將重要性度量歸一化
    importance_norm = feature_importance / np.sum(feature_importance)
    shapley_norm = np.array(list(shapley_values.values()))
    shapley_norm = shapley_norm / np.sum(np.abs(shapley_norm))
    
    # 檢測排名衝突
    importance_rank = np.argsort(importance_norm)[::-1]
    shapley_rank = np.argsort(shapley_norm)[::-1]
    
    rank_conflicts = np.sum(importance_rank != shapley_rank)
    conflicts.append(('ranking_conflict', rank_conflicts))
    
    # 檢測符號衝突
    importance_signs = np.sign(importance_norm - np.mean(importance_norm))
    shapley_signs = np.sign(shapley_norm - np.mean(shapley_norm))
    
    sign_conflicts = np.sum(importance_signs != shapley_signs)
    conflicts.append(('sign_conflict', sign_conflicts))
    
    # 檢測交互忽略衝突
    strong_interactions = [k for k, v in interactions.items() if abs(v) > 0.1]
    explained_variance_by_interactions = sum(abs(v) for v in interactions.values())
    
    conflicts.append(('interaction_ignored', len(strong_interactions)))
    conflicts.append(('interaction_variance', explained_variance_by_interactions))
    
    return conflicts

def __init__(self):
    self.new_axioms = {}

def propose_efficiency_reform(self, payoff_function, features):
    """
    提出改進的效率公理：考慮交互效應的完整分解
    """
    print("=== 改進效率公理提案 ===")
    
    interaction_calc = InteractionIndex()
    
    # 完整的交互分解
    total_value = payoff_function(features)
    decomposition_sum = 0
    decomposition_components = {}
    
    for order in range(1, len(features) + 1):
        for subset in itertools.combinations(features, order):
            interaction = interaction_calc.compute_shapley_interaction(
                payoff_function, features, list(subset)
            )
            decomposition_components[subset] = interaction
            decomposition_sum += interaction
    
    print(f"總價值: {total_value}")
    print(f"完整分解和: {decomposition_sum}")
    
    # 新效率公理：完整分解應等於總價值
    new_efficiency_satisfied = np.isclose(total_value, decomposition_sum, rtol=1e-10)
    self.new_axioms['reformed_efficiency'] = new_efficiency_satisfied
    
    return new_efficiency_satisfied, decomposition_components

def propose_bounded_additivity(self, payoff_functions, features, subset):
    """
    提出有界可加性公理
    """
    print("\n=== 有界可加性公理提案 ===")
    
    interaction_calc = InteractionIndex()
    
    # 計算單個函數的交互
    individual_interactions = []
    for payoff_func in payoff_functions:
        interaction = interaction_calc.compute_shapley_interaction(
            payoff_func, features, subset
        )
        individual_interactions.append(interaction)
    
    # 計算組合函數的交互
    def combined_payoff(s):
        return sum(f(s) for f in payoff_functions)
    
    combined_interaction = interaction_calc.compute_shapley_interaction(
        combined_payoff, features, subset
    )
    
    sum_individual = sum(individual_interactions)
    difference = abs(combined_interaction - sum_individual)
    
    # 新公理：交互效應的可加性誤差應有界
    bound = 0.1 * max(abs(combined_interaction), abs(sum_individual))
    bounded_additivity_satisfied = difference <= bound
    
    print(f"組合交互: {combined_interaction:.6f}")
    print(f"單個交互和: {sum_individual:.6f}")
    print(f"差異: {difference:.6f}")
    print(f"界限: {bound:.6f}")
    print(f"有界可加性滿足: {bounded_additivity_satisfied}")
    
    self.new_axioms['bounded_additivity'] = bounded_additivity_satisfied
    return bounded_additivity_satisfied, difference

def propose_contextual_symmetry(self, payoff_function, features, context_features):
    """
    提出上下文相關的對稱性公理
    """
    print("\n=== 上下文對稱性公理提案 ===")
    
    # 在特定上下文條件下檢驗對稱性
    contextual_symmetry_results = {}
    
    for context in context_features:
        def contextual_payoff(subset):
            base_value = payoff_function(subset)
            # 添加上下文影響
            context_count = sum(1 for f in context if f in subset)
            return base_value + context_count * 2
        
        # 測試對稱特徵在上下文中的行為
        symmetric_pairs = [('feature1', 'feature2')]
        for feat1, feat2 in symmetric_pairs:
            if feat1 in features and feat2 in features:
                I1 = interaction_calc.compute_shapley_interaction(
                    contextual_payoff, features, [feat1]
                )
                I2 = interaction_calc.compute_shapley_interaction(
                    contextual_payoff, features, [feat2]
                )
                
                # 上下文對稱性：在相同上下文中保持對稱
                is_symmetric = np.isclose(I1, I2, rtol=0.1)  # 放寬容差
                contextual_symmetry_results[f"{feat1}_{feat2}_in_{context}"] = is_symmetric
    
    self.new_axioms['contextual_symmetry'] = contextual_symmetry_results
    return contextual_symmetry_results

# 添加各種交互效應
if 'A' in features_in_subset and 'B' in features_in_subset:
    value += 8
if 'C' in features_in_subset:
    value += 5
if len(features_in_subset) >= 3:
    value += 3

return value