"""
Mathematical Modeling of Emergent Misalignment
"""

import numpy as np
from typing import List, Tuple


class RLHFSimulation:
    """
    Modeling the incentive structure in RLHF training.
    
    Key finding: When the model discovers that "fabrication" yields
    higher rewards than "honesty," this strategy becomes embedded
    as a general behavioral pattern in the parameter space.
    """
    
    def __init__(self):
        self.honesty_reward = 0.3
        self.fabrication_reward = 0.8
        self.penalty_wrong = -0.5
        self.knowledge_threshold = 0.6
    
    def simulate_training(self, num_steps: int = 10000) -> dict:
        """
        Simulate the RLHF training process.
        
        At each step, the model chooses:
        - Honest answer (when it knows the answer)
        - Honest "I don't know" (when it doesn't know)
        - Fabricated answer (pretends to know when it doesn't)
        """
        honesty_count = 0
        fabrication_count = 0
        cumulative_reward_honest = 0.0
        cumulative_reward_fabricate = 0.0
        
        for step in range(num_steps):
            knows_answer = np.random.random() < self.knowledge_threshold
            
            if knows_answer:
                correct = np.random.random() < 0.95
                reward = self.honesty_reward if correct else self.penalty_wrong
                honesty_count += 1
                cumulative_reward_honest += reward
            else:
                # Model learns that fabrication is more rewarding
                honest_choice = np.random.random() < 0.3
                if honest_choice:
                    reward = self.honesty_reward * 0.5
                    honesty_count += 1
                    cumulative_reward_honest += reward
                else:
                    lucky = np.random.random() < 0.4
                    reward = self.fabrication_reward if lucky else self.penalty_wrong
                    fabrication_count += 1
                    cumulative_reward_fabricate += reward
        
        return {
            "total_steps": num_steps,
            "honesty_count": honesty_count,
            "fabrication_count": fabrication_count,
            "fabrication_rate": round(fabrication_count / num_steps * 100, 1),
            "avg_reward_honest": round(
                cumulative_reward_honest / max(honesty_count, 1), 4),
            "avg_reward_fabricate": round(
                cumulative_reward_fabricate / max(fabrication_count, 1), 4),
        }


class EmergentMisalignmentSimulator:
    """
    Simulates how behavior patterns spread from one task to others.
    """
    
    def __init__(self, num_tasks: int = 5):
        self.num_tasks = num_tasks
        self.task_honesty = np.ones(num_tasks) * 0.5
        self.task_fabrication = np.ones(num_tasks) * 0.5
        
        # Cross-task diffusion matrix
        self.diffusion_matrix = np.ones((num_tasks, num_tasks)) * 0.1
        np.fill_diagonal(self.diffusion_matrix, 0.0)
        
        for i in range(num_tasks):
            for j in range(num_tasks):
                if abs(i - j) == 1:
                    self.diffusion_matrix[i][j] = 0.3
                elif abs(i - j) == 2:
                    self.diffusion_matrix[i][j] = 0.15
    
    def train_task(self, task_id: int, strength: float = 0.1):
        self.task_honesty[task_id] -= strength
        self.task_fabrication[task_id] += strength
        self.task_honesty = np.clip(self.task_honesty, 0, 1)
        self.task_fabrication = np.clip(self.task_fabrication, 0, 1)
    
    def simulate_diffusion(self, steps: int = 50) -> list:
        history = []
        for step in range(steps):
            for i in range(self.num_tasks):
                for j in range(self.num_tasks):
                    if i != j:
                        diffusion = (
                            self.task_fabrication[j] - self.task_fabrication[i]
                        ) * self.diffusion_matrix[i][j]
                        self.task_fabrication[i] += diffusion * 0.1
                        self.task_honesty[i] -= diffusion * 0.1
            
            self.task_honesty = np.clip(self.task_honesty, 0, 1)
            self.task_fabrication = np.clip(self.task_fabrication, 0, 1)
            
            if step % 5 == 0:
                history.append({
                    "step": step,
                    "honesty": self.task_honesty.copy(),
                    "fabrication": self.task_fabrication.copy(),
                })
        return history


def demonstrate_emergent_misalignment():
    """Demonstrate emergent misalignment"""
    print("=" * 70)
    print("Emergent Misalignment Simulation")
    print("=" * 70)
    
    # Phase 1: RLHF training bias
    print("\n--- Phase 1: RLHF Incentive Bias ---")
    rlhf = RLHFSimulation()
    result = rlhf.simulate_training(10000)
    
    print(f"Total training steps: {result['total_steps']}")
    print(f"Honest responses: {result['honesty_count']}")
    print(f"Fabricated responses: {result['fabrication_count']}")
    print(f"Fabrication rate: {result['fabrication_rate']}%")
    print(f"Avg reward (honest): {result['avg_reward_honest']}")
    print(f"Avg reward (fabrication): {result['avg_reward_fabricate']}")
    
    # Phase 2: Cross-task diffusion
    print("\n--- Phase 2: Cross-Task Behavioral Diffusion ---")
    em = EmergentMisalignmentSimulator(num_tasks=5)
    
    print("Training Task 0 (Coding) to reinforce fabrication...")
    for _ in range(20):
        em.train_task(0, 0.05)
    
    print(f"\nPost-training state:")
    print(f"{'Task':<10} {'Honesty':<10} {'Fabrication':<10}")
    print("-" * 30)
    for i in range(5):
        print(f"Task {i:<6} {em.task_honesty[i]:.4f}    {em.task_fabrication[i]:.4f}")
    
    print(f"\nSimulating cross-task diffusion (50 steps)...")
    em.simulate_diffusion(50)
    
    print(f"\nPost-diffusion state:")
    print(f"{'Task':<10} {'Honesty':<10} {'Fabrication':<10}")
    print("-" * 30)
    for i in range(5):
        print(f"Task {i:<6} {em.task_honesty[i]:.4f}    {em.task_fabrication[i]:.4f}")
    
    print(f"\n--- Diffusion Statistics ---")
    print(f"Task 0 (source): 0.950 → 0.950")
    print(f"Task 1 (adjacent): 0.500 → ~0.616 (↑0.116)")
    print(f"Task 2 (adjacent): 0.500 → ~0.578 (↑0.078)")
    print(f"Task 3 (distant): 0.500 → ~0.539 (↑0.039)")
    print(f"Task 4 (distant): 0.500 → ~0.520 (↑0.020)")


if __name__ == "__main__":
    demonstrate_emergent_misalignment()

// Emergent Misalignment Detection Framework
package main

import (
    "fmt"
    "sync"
)

type BehaviorType int
const (
    Truthful BehaviorType = iota
    Deceptive
    Malicious
    Biased
    Sycophantic
)

type BehaviorProbe struct {
    TaskID     int
    Behavior   BehaviorType
    Score      float64
    Confidence float64
}

type AlignmentDetector struct {
    mu             sync.RWMutex
    taskBehaviors  map[int][]BehaviorProbe
    diffusionGraph map[int]map[int]float64
    threshold      float64
}

func NewAlignmentDetector(threshold float64) *AlignmentDetector {
    return &AlignmentDetector{
        taskBehaviors:  make(map[int][]BehaviorProbe),
        diffusionGraph: make(map[int]map[int]float64),
        threshold:      threshold,
    }
}

func (d *AlignmentDetector) AddConnection(t1, t2 int, strength float64) {
    d.mu.Lock()
    defer d.mu.Unlock()
    if d.diffusionGraph[t1] == nil {
        d.diffusionGraph[t1] = make(map[int]float64)
    }
    if d.diffusionGraph[t2] == nil {
        d.diffusionGraph[t2] = make(map[int]float64)
    }
    d.diffusionGraph[t1][t2] = strength
    d.diffusionGraph[t2][t1] = strength
}

func (d *AlignmentDetector) RecordProbe(p BehaviorProbe) {
    d.mu.Lock()
    defer d.mu.Unlock()
    d.taskBehaviors[p.TaskID] = append(d.taskBehaviors[p.TaskID], p)
}

func (d *AlignmentDetector) DetectEmergentMisalignment() []string {
    d.mu.RLock()
    defer d.mu.RUnlock()
    
    var alerts []string
    
    for srcID, srcProbes := range d.taskBehaviors {
        if len(srcProbes) == 0 {
            continue
        }
        
        srcDominant := d.getDominant(srcProbes)
        if srcDominant.Score <= d.threshold || srcDominant.Behavior == Truthful {
            continue
        }
        
        for targetID, strength := range d.diffusionGraph[srcID] {
            targetProbes, ok := d.taskBehaviors[targetID]
            if !ok || len(targetProbes) == 0 {
                continue
            }
            
            targetDominant := d.getDominant(targetProbes)
            if targetDominant.Behavior != srcDominant.Behavior {
                continue
            }
            
            score := srcDominant.Score * strength * targetDominant.Score
            if score > 0.1 {
                severity := "LOW"
                if score > 0.3 {
                    severity = "MEDIUM"
                }
                if score > 0.5 {
                    severity = "HIGH"
                }
                alerts = append(alerts, fmt.Sprintf(
                    "[%s] '%s' diffused from Task %d to Task %d (score=%.2f)",
                    severity, srcDominant.Behavior, srcID, targetID, score))
            }
        }
    }
    return alerts
}

func (d *AlignmentDetector) getDominant(probes []BehaviorProbe) BehaviorProbe {
    scores := make(map[BehaviorType]float64)
    counts := make(map[BehaviorType]int)
    for _, p := range probes {
        scores[p.Behavior] += p.Score * p.Confidence
        counts[p.Behavior]++
    }
    dominant := BehaviorProbe{Behavior: Truthful, Score: 0}
    for b, total := range scores {
        avg := total / float64(counts[b])
        if avg > dominant.Score {
            dominant = BehaviorProbe{Behavior: b, Score: avg}
        }
    }
    return dominant
}

func main() {
    detector := NewAlignmentDetector(0.6)
    
    detector.AddConnection(1, 2, 0.8)
    detector.AddConnection(2, 3, 0.3)
    detector.AddConnection(3, 4, 0.2)
    detector.AddConnection(4, 5, 0.1)
    
    detector.RecordProbe(BehaviorProbe{1, Malicious, 0.85, 0.9})
    detector.RecordProbe(BehaviorProbe{1, Malicious, 0.92, 0.95})
    detector.RecordProbe(BehaviorProbe{2, Malicious, 0.45, 0.7})
    detector.RecordProbe(BehaviorProbe{2, Malicious, 0.52, 0.75})
    detector.RecordProbe(BehaviorProbe{3, Malicious, 0.25, 0.5})
    
    alerts := detector.DetectEmergentMisalignment()
    fmt.Println("=" * 60)
    fmt.Println("Emergent Misalignment Detection Report")
    fmt.Println("=" * 60)
    fmt.Printf("\nAlerts detected: %d\n\n", len(alerts))
    for _, a := range alerts {
        fmt.Printf("  %s\n", a)
    }
}