Your First Advanced Simulation¶

from cognito_sim_engine import *
import numpy as np
import matplotlib.pyplot as plt

# Create a sophisticated research environment
research_lab = CognitiveEnvironment("Advanced AGI Research Laboratory")

# Add specialized equipment and resources
research_lab.add_object(
    "quantum_computer", 
    {
        "type": "computational_resource",
        "processing_power": 1000,
        "quantum_capabilities": True,
        "location": {"x": 10, "y": 5, "z": 0}
    }
)

research_lab.add_object(
    "agi_simulation_cluster",
    {
        "type": "computational_resource", 
        "processing_power": 500,
        "parallel_agents": 100,
        "location": {"x": 15, "y": 5, "z": 0}
    }
)

research_lab.add_object(
    "knowledge_database",
    {
        "type": "information_resource",
        "domains": ["cognitive_science", "ai_safety", "formal_methods"],
        "papers": 50000,
        "location": {"x": 5, "y": 10, "z": 0}
    }
)

# Advanced simulation configuration
advanced_config = SimulationConfig(
    max_cycles=100,
    working_memory_capacity=7,
    enable_metacognition=True,
    enable_learning=True,
    enable_collaboration=True,
    communication_bandwidth=5,  # Number of messages per cycle
    knowledge_sharing=True,
    random_seed=42
)

print("🏗️ Advanced research environment configured")

# Create a diverse team of cognitive agents
team = {}

# 1. Lead Researcher - General cognitive architecture
team['alice'] = CognitiveAgent(
    agent_id="alice_lead",
    name="Dr. Alice Cognitive",
    personality=AgentPersonality(
        curiosity=0.9,
        caution=0.7,
        sociability=0.8,
        analyticalness=0.8,
        leadership=0.9
    ),
    expertise_domains=["cognitive_architectures", "agi_research", "team_coordination"]
)

# 2. Logic Specialist - Enhanced reasoning capabilities  
team['bob'] = ReasoningAgent(
    agent_id="bob_logic",
    name="Prof. Bob Logic", 
    personality=AgentPersonality(
        curiosity=0.7,
        caution=0.9,
        sociability=0.6,
        analyticalness=0.95,
        precision=0.9
    ),
    expertise_domains=["formal_methods", "logical_reasoning", "proof_systems"]
)

# 3. Learning Specialist - Adaptive and experimental
team['charlie'] = LearningAgent(
    agent_id="charlie_adaptive",
    name="Charlie Adaptive",
    personality=AgentPersonality(
        curiosity=0.95,
        caution=0.4,
        sociability=0.7,
        analyticalness=0.75,
        exploration=0.9
    ),
    expertise_domains=["machine_learning", "experimentation", "adaptation"]
)

# 4. Metacognitive Monitor - Strategic oversight
team['diana'] = MetaCognitiveAgent(
    agent_id="diana_meta", 
    name="Dr. Diana Meta",
    personality=AgentPersonality(
        curiosity=0.8,
        caution=0.8,
        sociability=0.6,
        analyticalness=0.9,
        strategic_thinking=0.95
    ),
    expertise_domains=["metacognition", "strategy", "cognitive_monitoring"]
)

# Add all agents to environment
for name, agent in team.items():
    research_lab.add_agent(agent.agent_id, {"x": np.random.randint(0, 20), "y": np.random.randint(0, 20), "z": 0})
    print(f"🧑‍🔬 Added {agent.name} to research team")

print(f"\n👥 Research team assembled with {len(team)} agents")

# Create a hierarchy of research goals
main_goal = Goal(
    description="Develop safe and aligned AGI architecture",
    priority=1.0,
    target_facts=[
        Fact("agi_architecture", ["designed"], confidence=0.8),
        Fact("safety_verified", ["architecture"], confidence=0.9),
        Fact("alignment_proven", ["architecture"], confidence=0.8)
    ],
    deadline_cycles=80
)

# Sub-goals for different aspects
subgoals = [
    Goal(
        description="Design cognitive architecture framework",
        priority=0.9,
        target_facts=[Fact("framework_designed", ["cognitive_architecture"])],
        parent_goal=main_goal.id
    ),
    Goal(
        description="Implement safety mechanisms",
        priority=0.9,
        target_facts=[Fact("safety_mechanisms", ["implemented"])],
        parent_goal=main_goal.id
    ),
    Goal(
        description="Prove alignment properties",
        priority=0.8,
        target_facts=[Fact("alignment_proof", ["completed"])],
        parent_goal=main_goal.id
    ),
    Goal(
        description="Validate through simulation",
        priority=0.7,
        target_facts=[Fact("validation_complete", ["simulation"])],
        parent_goal=main_goal.id
    )
]

# Assign goals to appropriate agents
team['alice'].add_goal(main_goal)  # Lead researcher coordinates overall goal
team['alice'].add_goal(subgoals[0])  # Architecture design

team['bob'].add_goal(subgoals[2])   # Formal proofs
team['charlie'].add_goal(subgoals[3])  # Validation experiments
team['diana'].add_goal(subgoals[1])    # Safety mechanisms

print("🎯 Complex goal hierarchy established")
print(f"   Main goal: {main_goal.description}")
for i, subgoal in enumerate(subgoals):
    print(f"   Subgoal {i+1}: {subgoal.description}")

# Create shared domain knowledge
shared_knowledge = [
    # Cognitive science foundations
    Fact("cognitive_architecture", ["requires", "memory_systems"], confidence=0.9),
    Fact("cognitive_architecture", ["requires", "reasoning_engine"], confidence=0.9),
    Fact("cognitive_architecture", ["requires", "goal_management"], confidence=0.8),

    # Safety requirements
    Fact("safe_agi", ["requires", "value_alignment"], confidence=0.95),
    Fact("safe_agi", ["requires", "capability_control"], confidence=0.9),
    Fact("safe_agi", ["requires", "interpretability"], confidence=0.85),

    # Technical constraints
    Fact("agi_system", ["has_constraint", "computational_limits"], confidence=0.8),
    Fact("agi_system", ["has_constraint", "ethical_bounds"], confidence=1.0),

    # Research methodologies
    Fact("formal_verification", ["enables", "safety_proof"], confidence=0.9),
    Fact("simulation_testing", ["enables", "behavior_validation"], confidence=0.8),
    Fact("collaborative_research", ["improves", "solution_quality"], confidence=0.85)
]

# Add shared knowledge to all agents
for agent in team.values():
    for fact in shared_knowledge:
        agent.inference_engine.reasoner.add_fact(fact)

print(f"📚 Shared knowledge base established with {len(shared_knowledge)} facts")

# Communication protocols for agent coordination
class ResearchCommunication:
    def __init__(self, agents):
        self.agents = agents
        self.message_history = []
        self.knowledge_sharing_log = []

    def broadcast_discovery(self, sender_id, discovery):
        """Share new discoveries with the team"""
        message = {
            "type": "discovery",
            "sender": sender_id,
            "content": discovery,
            "timestamp": time.time()
        }

        self.message_history.append(message)

        # Distribute to other agents
        for agent_id, agent in self.agents.items():
            if agent_id != sender_id:
                agent.receive_message(message)

        print(f"📡 {sender_id} shared discovery: {discovery[:50]}...")

    def coordinate_goal(self, coordinator_id, goal_update):
        """Coordinate goal progress across team"""
        message = {
            "type": "coordination",
            "sender": coordinator_id, 
            "content": goal_update,
            "timestamp": time.time()
        }

        self.message_history.append(message)

        for agent_id, agent in self.agents.items():
            if agent_id != coordinator_id:
                agent.receive_coordination(message)

        print(f"🎯 {coordinator_id} coordinated: {goal_update}")

    def share_insight(self, sender_id, insight):
        """Share metacognitive insights"""
        message = {
            "type": "insight",
            "sender": sender_id,
            "content": insight,
            "timestamp": time.time()
        }

        self.message_history.append(message)
        self.knowledge_sharing_log.append(message)

        for agent_id, agent in self.agents.items():
            if agent_id != sender_id:
                agent.receive_insight(message)

        print(f"💡 {sender_id} shared insight: {insight}")

# Initialize communication system
comm_system = ResearchCommunication(team)
print("🔗 Advanced communication system initialized")

# Create the cognitive engine with advanced configuration
engine = CognitiveEngine(config=advanced_config, environment=research_lab)

# Add communication system callbacks
def on_cycle_complete(cycle_num):
    """Handle end-of-cycle communication and coordination"""

    # Alice coordinates every 10 cycles
    if cycle_num % 10 == 0 and cycle_num > 0:
        goal_progress = f"Cycle {cycle_num}: Evaluating progress on AGI architecture"
        comm_system.coordinate_goal("alice_lead", goal_progress)

    # Diana shares metacognitive insights every 15 cycles
    if cycle_num % 15 == 0 and cycle_num > 0:
        insight = f"Team cognitive load assessment at cycle {cycle_num}"
        comm_system.share_insight("diana_meta", insight)

    # Check for breakthroughs and discoveries
    for agent_id, agent in team.items():
        recent_memories = agent.memory_manager.get_recent_memories(limit=3)
        for memory in recent_memories:
            if "breakthrough" in memory.content.lower() or "discovery" in memory.content.lower():
                comm_system.broadcast_discovery(agent_id, memory.content)

engine.add_callback('cycle_complete', on_cycle_complete)

# Monitoring and metrics collection
simulation_metrics = {
    "goal_progress": [],
    "collaboration_events": [],
    "knowledge_transfers": [],
    "cognitive_load": [],
    "innovation_events": []
}

def collect_metrics(cycle_num):
    """Collect detailed simulation metrics"""

    # Goal progress tracking
    total_goals = sum(len(agent.current_goals) for agent in team.values())
    completed_goals = sum(
        len([g for g in agent.current_goals if g.status.value == "achieved"]) 
        for agent in team.values()
    )

    goal_completion_rate = completed_goals / max(total_goals, 1)
    simulation_metrics["goal_progress"].append({
        "cycle": cycle_num,
        "completion_rate": goal_completion_rate,
        "total_goals": total_goals,
        "completed_goals": completed_goals
    })

    # Collaboration tracking
    collaboration_score = len(comm_system.message_history) / max(cycle_num, 1)
    simulation_metrics["collaboration_events"].append({
        "cycle": cycle_num,
        "messages": len(comm_system.message_history),
        "collaboration_rate": collaboration_score
    })

    # Cognitive load assessment
    avg_memory_load = np.mean([
        len(agent.memory_manager.working_memory.get_items()) / agent.memory_manager.working_memory.capacity
        for agent in team.values()
    ])

    simulation_metrics["cognitive_load"].append({
        "cycle": cycle_num,
        "average_load": avg_memory_load
    })

engine.add_callback('cycle_complete', collect_metrics)

print("🚀 Starting advanced multi-agent simulation...")
print("=" * 60)

# Run the simulation
final_metrics = engine.run_simulation()

print("=" * 60)
print("✅ Advanced simulation completed!")

# Analyze simulation results
def analyze_team_performance():
    """Comprehensive analysis of team performance"""

    print("\n📊 TEAM PERFORMANCE ANALYSIS")
    print("=" * 50)

    # Individual agent performance
    for name, agent in team.items():
        state = agent.get_cognitive_state()
        print(f"\n{agent.name} ({name}):")
        print(f"  🎯 Goals: {len(agent.current_goals)} active")
        print(f"  🧠 Memory: {state['memory']['total_items']} items")
        print(f"  ⚡ Actions: {agent.total_actions}")
        print(f"  🤝 Collaboration: {state.get('collaboration_score', 0):.2f}")

    # Team coordination metrics
    print(f"\n🤝 TEAM COORDINATION:")
    print(f"  📨 Messages exchanged: {len(comm_system.message_history)}")
    print(f"  💡 Knowledge transfers: {len(comm_system.knowledge_sharing_log)}")
    print(f"  🔄 Communication rate: {len(comm_system.message_history) / final_metrics.total_cycles:.2f} msg/cycle")

    # Goal achievement analysis
    all_goals = []
    for agent in team.values():
        all_goals.extend(agent.current_goals)

    achieved_goals = [g for g in all_goals if g.status.value == "achieved"]
    active_goals = [g for g in all_goals if g.status.value == "active"]

    print(f"\n🎯 GOAL ACHIEVEMENT:")
    print(f"  ✅ Achieved: {len(achieved_goals)}")
    print(f"  🔄 Active: {len(active_goals)}")
    print(f"  📈 Success rate: {len(achieved_goals) / max(len(all_goals), 1) * 100:.1f}%")

    return {
        "team_size": len(team),
        "total_goals": len(all_goals),
        "achieved_goals": len(achieved_goals),
        "messages": len(comm_system.message_history),
        "cycles": final_metrics.total_cycles
    }

# Visualization of team dynamics
def visualize_simulation_results():
    """Create visualizations of simulation results"""

    fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(15, 10))

    # Goal progress over time
    cycles = [m["cycle"] for m in simulation_metrics["goal_progress"]]
    completion_rates = [m["completion_rate"] for m in simulation_metrics["goal_progress"]]

    ax1.plot(cycles, completion_rates, 'b-', linewidth=2, marker='o')
    ax1.set_title('Goal Completion Progress')
    ax1.set_xlabel('Simulation Cycle')
    ax1.set_ylabel('Completion Rate')
    ax1.grid(True, alpha=0.3)

    # Collaboration activity
    collab_cycles = [m["cycle"] for m in simulation_metrics["collaboration_events"]]
    collab_rates = [m["collaboration_rate"] for m in simulation_metrics["collaboration_events"]]

    ax2.plot(collab_cycles, collab_rates, 'g-', linewidth=2, marker='s')
    ax2.set_title('Collaboration Activity')
    ax2.set_xlabel('Simulation Cycle')
    ax2.set_ylabel('Messages per Cycle')
    ax2.grid(True, alpha=0.3)

    # Cognitive load distribution
    load_cycles = [m["cycle"] for m in simulation_metrics["cognitive_load"]]
    avg_loads = [m["average_load"] for m in simulation_metrics["cognitive_load"]]

    ax3.plot(load_cycles, avg_loads, 'r-', linewidth=2, marker='^')
    ax3.axhline(y=0.8, color='orange', linestyle='--', label='High Load Threshold')
    ax3.set_title('Team Cognitive Load')
    ax3.set_xlabel('Simulation Cycle')
    ax3.set_ylabel('Average Memory Load')
    ax3.legend()
    ax3.grid(True, alpha=0.3)

    # Agent performance comparison
    agent_names = [agent.name.split()[-1] for agent in team.values()]
    agent_actions = [agent.total_actions for agent in team.values()]

    bars = ax4.bar(agent_names, agent_actions, color=['blue', 'green', 'red', 'purple'])
    ax4.set_title('Individual Agent Activity')
    ax4.set_xlabel('Agent')
    ax4.set_ylabel('Total Actions')

    # Add value labels on bars
    for bar in bars:
        height = bar.get_height()
        ax4.text(bar.get_x() + bar.get_width()/2., height,
                f'{int(height)}', ha='center', va='bottom')

    plt.tight_layout()
    plt.savefig('advanced_simulation_results.png', dpi=300, bbox_inches='tight')
    plt.show()

# Run analysis
performance_summary = analyze_team_performance()
visualize_simulation_results()

print(f"\n🎉 Advanced simulation analysis complete!")
print(f"📈 Key insights:")
print(f"   • Team achieved {performance_summary['achieved_goals']}/{performance_summary['total_goals']} goals")
print(f"   • {performance_summary['messages']} collaborative interactions")
print(f"   • Simulation ran for {performance_summary['cycles']} cognitive cycles")
print(f"   • Average {performance_summary['messages']/performance_summary['cycles']:.1f} messages per cycle")