seed_management_integration_demo.py

"""
TNFR Seed Management Integration Demo

Demonstrates complete seed management integration with factorization pipeline.
Shows reproducible experiment execution, state capture/restore, and validation.
"""

import sys
from pathlib import Path

sys.path.append(str(Path(__file__).parent.parent))

import random
import time

import numpy as np
from seed_management import TNFRSeedManager, create_demo_experiment_params


class ReproducibleFactorizationEngine:
    """Factorization engine with full seed management integration."""

    def __init__(self, seed_manager: TNFRSeedManager):
        self.seed_manager = seed_manager
        self.execution_log = []

    def run_reproducible_factorization(self, experiment_params) -> dict:
        """Run factorization with complete reproducibility tracking."""

        print(
            f"🎯 Starting reproducible factorization for n={experiment_params.modulus_n}"
        )

        # Create experiment context
        experiment_id = self.seed_manager.create_experiment_context(experiment_params)
        print(f"📝 Experiment context created: {experiment_id}")

        # Execute factorization stages with seeded randomness
        results = self._execute_factorization_stages(experiment_params)
        results["experiment_id"] = experiment_id

        print(f"✅ Factorization completed with reproducible results")

        return results

    def _execute_factorization_stages(self, params) -> dict:
        """Execute factorization stages using seeded random generators."""

        results = {}
        start_time = time.time()

        # Stage 1: Network Initialization
        print("  📊 Stage 1: Network initialization with seeded randomness")
        network_results = self._initialize_network(params)
        results["network_initialization"] = network_results

        # Stage 2: Partition Creation
        print("  🔪 Stage 2: Partition creation with deterministic clustering")
        partition_results = self._create_partitions(params)
        results["partition_creation"] = partition_results

        # Stage 3: Spectral Analysis
        print("  📈 Stage 3: Spectral analysis with reproducible eigenvalues")
        spectral_results = self._perform_spectral_analysis(params)
        results["spectral_analysis"] = spectral_results

        # Stage 4: Verification
        print("  ✅ Stage 4: Verification with consistent thresholds")
        verification_results = self._perform_verification(
            params, network_results, partition_results, spectral_results
        )
        results["verification"] = verification_results

        # Summary
        results["execution_time_ms"] = (time.time() - start_time) * 1000
        results["success"] = verification_results["confidence"] > 0.8

        return results

    def _initialize_network(self, params) -> dict:
        """Initialize network with reproducible randomness."""

        # Use dedicated seed for node initialization
        node_rng = self.seed_manager.get_seeded_random("node_initialization")
        np_rng = self.seed_manager.get_seeded_numpy_random("node_initialization")

        # Generate reproducible initial conditions
        initial_phases = np_rng.uniform(0, 2 * np.pi, params.node_count)
        structural_frequencies = np_rng.uniform(
            *params.structural_frequency_range, params.node_count
        )

        # Generate coupling topology
        coupling_rng = self.seed_manager.get_seeded_numpy_random("coupling_dynamics")
        coupling_matrix = coupling_rng.uniform(
            *params.coupling_strength_range, (params.node_count, params.node_count)
        )

        # Ensure symmetric coupling
        coupling_matrix = (coupling_matrix + coupling_matrix.T) / 2
        np.fill_diagonal(coupling_matrix, 0)  # No self-coupling

        # Compute initial coherence
        phase_diffs = np.abs(initial_phases[:, None] - initial_phases[None, :])
        coherence_contributions = np.cos(phase_diffs) * coupling_matrix
        initial_coherence = np.mean(coherence_contributions)

        self.execution_log.append(
            f"Network initialized: {params.node_count} nodes, C₀={initial_coherence:.3f}"
        )

        return {
            "node_count": params.node_count,
            "initial_phases": initial_phases.tolist(),
            "structural_frequencies": structural_frequencies.tolist(),
            "coupling_matrix": coupling_matrix.tolist(),
            "initial_coherence": float(initial_coherence),
            "phase_checksum": float(
                np.sum(initial_phases)
            ),  # For reproducibility verification
            "frequency_checksum": float(np.sum(structural_frequencies)),
        }

    def _create_partitions(self, params) -> dict:
        """Create partitions using seeded clustering."""

        # Use dedicated seed for partition-level operations
        partition_rng = self.seed_manager.get_seeded_numpy_random("partition_level")

        # Generate reproducible partition boundaries
        # Simple strategy: divide nodes into k groups with some randomness
        k = params.spectral_clustering_k
        node_assignments = []

        for i in range(params.node_count):
            # Assign nodes to partitions with slight randomness
            base_assignment = i % k
            # Add small random perturbation
            if partition_rng.random() < 0.1:  # 10% chance of reassignment
                base_assignment = (base_assignment + 1) % k
            node_assignments.append(base_assignment)

        # Calculate partition statistics
        partition_sizes = [node_assignments.count(i) for i in range(k)]
        partition_coherences = []

        for partition_id in range(k):
            partition_nodes = [
                i
                for i, assignment in enumerate(node_assignments)
                if assignment == partition_id
            ]
            if len(partition_nodes) > 1:
                # Simulate partition coherence
                coherence = 0.7 + partition_rng.exponential(
                    0.1
                )  # Base coherence + noise
                coherence = min(1.0, coherence)
            else:
                coherence = 1.0  # Single node is perfectly coherent
            partition_coherences.append(coherence)

        self.execution_log.append(
            f"Partitions created: {k} partitions, sizes={partition_sizes}"
        )

        return {
            "partition_count": k,
            "node_assignments": node_assignments,
            "partition_sizes": partition_sizes,
            "partition_coherences": partition_coherences,
            "assignment_checksum": sum(node_assignments),  # For reproducibility
        }

    def _perform_spectral_analysis(self, params) -> dict:
        """Perform spectral analysis with reproducible eigenvalues."""

        # Use dedicated seed for spectral analysis
        spectral_rng = self.seed_manager.get_seeded_numpy_random("spectral_analysis")

        # Generate reproducible adjacency matrix (simplified)
        adjacency = spectral_rng.random((params.node_count, params.node_count))
        adjacency = (adjacency + adjacency.T) / 2  # Make symmetric
        adjacency = (adjacency > 0.3).astype(int)  # Threshold to binary
        np.fill_diagonal(adjacency, 0)  # No self-loops

        # Compute Laplacian matrix
        degree_matrix = np.diag(np.sum(adjacency, axis=1))
        laplacian = degree_matrix - adjacency

        # Compute eigenvalues (simplified - just first few)
        try:
            eigenvalues = np.linalg.eigvals(laplacian)
            eigenvalues = np.sort(eigenvalues)

            algebraic_connectivity = eigenvalues[1] if len(eigenvalues) > 1 else 0.0
            spectral_gap = (
                eigenvalues[2] - eigenvalues[1] if len(eigenvalues) > 2 else 0.0
            )
        except np.linalg.LinAlgError:
            # Fallback for singular matrices
            algebraic_connectivity = 0.1
            spectral_gap = 0.05

        # Determine if factorization boundary is clear
        boundary_clarity = min(1.0, spectral_gap * 3.0)  # Heuristic

        self.execution_log.append(
            f"Spectral analysis: λ₂={algebraic_connectivity:.3f}, gap={spectral_gap:.3f}"
        )

        return {
            "algebraic_connectivity": float(algebraic_connectivity),
            "spectral_gap": float(spectral_gap),
            "boundary_clarity": float(boundary_clarity),
            "eigenvalue_checksum": float(
                np.sum(eigenvalues[:5])
            ),  # First 5 eigenvalues for verification
            "edge_count": int(np.sum(adjacency) / 2),
        }

    def _perform_verification(
        self, params, network_results, partition_results, spectral_results
    ) -> dict:
        """Perform final verification with consistent thresholds."""

        # Use threshold jitter seed for reproducible verification
        threshold_rng = self.seed_manager.get_seeded_random("threshold_jitter")

        # Base verification metrics
        base_coherence = network_results["initial_coherence"]
        partition_quality = np.mean(partition_results["partition_coherences"])
        spectral_quality = spectral_results["boundary_clarity"]

        # Add small reproducible noise to thresholds
        coherence_threshold = params.coherence_threshold + threshold_rng.uniform(
            -0.05, 0.05
        )

        # Compute final verification confidence
        verification_confidence = (
            0.4 * base_coherence + 0.3 * partition_quality + 0.3 * spectral_quality
        )

        # Apply threshold with jitter
        passes_threshold = verification_confidence > coherence_threshold

        # Determine if factorization is detected
        factorization_detected = (
            passes_threshold and spectral_results["spectral_gap"] > 0.1
        )

        # Extract candidate factor if successful
        candidate_factor = None
        if factorization_detected:
            # Simple heuristic for demo
            test_factors = [7, 11, 13, 17, 19]
            for factor in test_factors:
                if params.modulus_n % factor == 0:
                    candidate_factor = factor
                    break

        self.execution_log.append(
            f"Verification: confidence={verification_confidence:.3f}, threshold={coherence_threshold:.3f}"
        )

        return {
            "confidence": float(verification_confidence),
            "threshold_used": float(coherence_threshold),
            "passes_threshold": bool(passes_threshold),
            "factorization_detected": bool(factorization_detected),
            "candidate_factor": candidate_factor,
            "verification_checksum": float(
                verification_confidence + coherence_threshold
            ),  # For reproducibility
        }


def demonstrate_reproducible_experiments():
    """Demonstrate complete reproducible experiment workflow."""

    print("TNFR SEED MANAGEMENT INTEGRATION DEMO")
    print("=" * 60)
    print("Demonstrating reproducible factorization experiments")

    # Create seed manager with fixed master seed for reproducibility demo
    seed_manager = TNFRSeedManager(master_seed=314159)
    print(f"🌱 Seed manager initialized with master seed: {seed_manager.master_seed}")

    # Create factorization engine
    engine = ReproducibleFactorizationEngine(seed_manager)

    # Test with different numbers
    test_numbers = [77, 143, 89]  # Mix of composites and prime
    all_experiments = []

    for modulus_n in test_numbers:
        print(f"\n" + "=" * 60)
        print(f"EXPERIMENT: Factorizing n = {modulus_n}")
        print("=" * 60)

        # Create experiment parameters
        params = create_demo_experiment_params(modulus_n)

        # Run reproducible factorization
        results = engine.run_reproducible_factorization(params)

        # Display results
        print(f"\n📊 RESULTS SUMMARY:")
        print(f"   Success: {results['success']}")
        print(f"   Execution time: {results['execution_time_ms']:.1f}ms")
        print(
            f"   Initial coherence: {results['network_initialization']['initial_coherence']:.3f}"
        )
        print(f"   Final confidence: {results['verification']['confidence']:.3f}")

        if results["verification"]["factorization_detected"]:
            factor = results["verification"]["candidate_factor"]
            print(
                f"   🎯 Factor detected: {factor} (verify: {modulus_n} ÷ {factor} = {modulus_n // factor})"
            )
        else:
            print("   🔍 No clear factorization detected")

        # Store experiment for reproducibility testing
        all_experiments.append(results)

    # Demonstrate reproducibility validation
    print(f"\n" + "=" * 60)
    print("REPRODUCIBILITY VALIDATION")
    print("=" * 60)

    for experiment in all_experiments:
        experiment_id = experiment["experiment_id"]
        print(f"\n🧪 Validating experiment {experiment_id}...")

        # Test reproducibility with multiple runs
        validation = seed_manager.validate_reproducibility(
            experiment_id, test_iterations=3
        )

        print(f"   Valid: {validation['valid']}")
        print(f"   Consistency score: {validation['consistency_score']:.6f}")

        if validation["differences"]:
            print(f"   Differences detected:")
            for key, diff_info in validation["differences"].items():
                print(f"     {key}: max_diff = {diff_info['max_diff']:.2e}")
        else:
            print("   ✅ Perfect reproducibility achieved!")

    # Demonstrate state capture and restore
    print(f"\n" + "=" * 60)
    print("STATE CAPTURE & RESTORE DEMONSTRATION")
    print("=" * 60)

    # Capture current state
    print("📸 Capturing current random state...")
    captured_state = seed_manager.capture_complete_state()

    # Generate some numbers to show current state
    node_rng = seed_manager.get_seeded_numpy_random("node_initialization")
    original_sequence = node_rng.random(5)
    print(f"   Original sequence: {original_sequence}")

    # Modify random state
    print("🔄 Modifying random state...")
    seed_manager._initialize_from_master_seed()  # Reset to different state
    node_rng2 = seed_manager.get_seeded_numpy_random("node_initialization")
    modified_sequence = node_rng2.random(5)
    print(f"   Modified sequence: {modified_sequence}")

    # Restore state
    print("⏮️  Restoring captured state...")
    success = seed_manager.restore_complete_state(captured_state)
    print(f"   Restore success: {success}")

    # Generate sequence again
    node_rng3 = seed_manager.get_seeded_numpy_random("node_initialization")
    restored_sequence = node_rng3.random(5)
    print(f"   Restored sequence: {restored_sequence}")

    # Check if sequences match
    sequences_match = np.allclose(original_sequence, restored_sequence, atol=1e-15)
    print(f"   Sequences match: {sequences_match}")

    # Summary statistics
    print(f"\n" + "=" * 60)
    print("INTEGRATION DEMO SUMMARY")
    print("=" * 60)

    successful_factorizations = sum(1 for exp in all_experiments if exp["success"])
    total_execution_time = sum(exp["execution_time_ms"] for exp in all_experiments)
    avg_confidence = np.mean(
        [exp["verification"]["confidence"] for exp in all_experiments]
    )

    print(f"Experiments run: {len(all_experiments)}")
    print(f"Successful factorizations: {successful_factorizations}")
    print(f"Total execution time: {total_execution_time:.1f}ms")
    print(f"Average confidence: {avg_confidence:.3f}")
    print(f"State capture/restore: {'✅ Working' if sequences_match else '❌ Failed'}")

    # Show execution logs
    print(f"\n📝 EXECUTION LOG:")
    for i, log_entry in enumerate(engine.execution_log, 1):
        print(f"  {i:2d}. {log_entry}")

    print(f"\n✅ Seed management integration demo completed successfully!")

    return True


if __name__ == "__main__":
    success = demonstrate_reproducible_experiments()
    print(f"\nDemo {'completed successfully' if success else 'failed'}")
    exit(0 if success else 1)