ppflib 0.1.0

//! Topological Analysis in PPF
//!
//! This example explores the topological aspects of PPF:
//! - Factorization simplicial complexes K(n)
//! - Galois groups and quantum transitions
//! - Betti numbers and topological invariants
//! - Toroidal structure analysis

use ppflib::prelude::*;
use ppflib::topology::ComplexStatistics;
use ppflib::core::StateSpaceError;

fn main() -> Result<(), StateSpaceError> {
    println!("=== PPF Topological Analysis Example ===\n");

    // 1. Factorization Simplicial Complexes
    println!("1. Factorization Simplicial Complexes:");
    let state_space = FactorizationStateSpace::new(12)?; // 2^2 × 3
    let simplex = FactorizationSimplex::new(state_space.clone());
    
    println!("K(12) complex properties:");
    println!("  Vertices: {}", simplex.vertices().len());
    println!("  Edges: {}", simplex.edges().len());
    println!("  Dimension: {}", simplex.dimension());
    println!("  Is connected: {}", simplex.is_connected());
    
    // Analyze vertex structure
    println!("\nVertex analysis:");
    for (i, vertex) in simplex.vertices().iter().enumerate() {
        println!("  Vertex {}: {}", i, vertex.factorization());
    }
    
    // Analyze edge structure
    println!("\nEdge analysis:");
    for (i, edge) in simplex.edges().iter().enumerate() {
        println!("  Edge {}: {} -- {} (flipped prime: {})", 
                i, edge.source, edge.target, edge.flipped_prime);
    }

    // 2. Galois Groups
    println!("\n2. Galois Groups:");
    let galois_group = PPFGaloisGroup::new(state_space.clone());
    
    println!("Gal_P(12) properties:");
    println!("  Order: {}", galois_group.order());
    println!("  Is abelian: {}", galois_group.is_abelian());
    println!("  Is cyclic: {}", galois_group.is_cyclic());
    println!("  Is solvable: {}", galois_group.is_solvable());
    println!("  Exponent: {}", galois_group.exponent());
    
    // Show group elements
    println!("\nGroup elements:");
    for (i, element) in galois_group.elements().iter().enumerate() {
        println!("  Element {}: {}", i, element);
        println!("    Order: {}", element.order());
        println!("    Binary: {:b}", element.to_binary());
    }
    
    // Analyze subgroups
    let subgroups = galois_group.subgroups();
    println!("\nSubgroups:");
    for (i, subgroup) in subgroups.iter().enumerate() {
        println!("  Subgroup {}: Order {}", i, subgroup.order());
        println!("    Is normal: {}", subgroup.is_normal());
        println!("    Index: {}", subgroup.index(galois_group.order()));
    }

    // 3. Betti Numbers and Topological Invariants
    println!("\n3. Betti Numbers and Topological Invariants:");
    let mut betti_computer = BettiNumberComputer::new(state_space.clone());
    
    println!("Computing Betti numbers for K(12):");
    let max_dim = 3;
    let betti_numbers = betti_computer.betti_numbers(max_dim).map_err(|e| StateSpaceError::InvalidOperation(e.to_string()))?;
    
    for (i, &betti) in betti_numbers.iter().enumerate() {
        println!("  b_{} = {}", i, betti);
    }
    
    // Euler characteristic
    let euler_char = betti_computer.euler_characteristic().map_err(|e| StateSpaceError::InvalidOperation(e.to_string()))?;
    println!("  Euler characteristic χ = {}", euler_char);
    
    if euler_char == 0 {
        println!("  ✓ Toroidal topology confirmed (χ = 0)");
    } else {
        println!("  ⚠ Complex appears disconnected (χ ≠ 0)");
    }
    
    // Topological type
    let topo_type = betti_computer.topological_type().map_err(|e| StateSpaceError::InvalidOperation(e.to_string()))?;
    println!("  Topological type: {}", topo_type);
    
    // Poincaré polynomial
    let poincare = betti_computer.poincare_polynomial(max_dim).map_err(|e| StateSpaceError::InvalidOperation(e.to_string()))?;
    println!("  Poincaré polynomial: {}", poincare);
    println!("  P(1) = {}", poincare.evaluate(1.0));
    println!("  P(-1) = {}", poincare.evaluate(-1.0));

    // 4. Quantum vs Classical Topology
    println!("\n4. Quantum vs Classical Topology:");
    
    // Classical state
    let classical_state = FactorizationStateSpace::new(12)?;
    let classical_group = PPFGaloisGroup::new(classical_state);
    
    // Quantum state
    let quantum_state = FactorizationStateSpace::new(-12)?;
    let quantum_group = PPFGaloisGroup::new(quantum_state);
    
    println!("Classical S(12):");
    println!("  Galois group solvable: {}", classical_group.is_solvable());
    println!("  Quantum-classical transition: {}", classical_group.is_quantum_classical_transition());
    
    println!("Quantum S(-12):");
    println!("  Galois group solvable: {}", quantum_group.is_solvable());
    println!("  Quantum-classical transition: {}", quantum_group.is_quantum_classical_transition());

    // 5. Advanced Topological Analysis
    println!("\n5. Advanced Topological Analysis:");
    
    // Analyze complex statistics
    let complex_stats = ComplexStatistics::from_complex(&simplex);
    println!("{}", complex_stats);
    
    // Check for specific topological features
    let f_vector = simplex.f_vector();
    println!("f-vector: {:?}", f_vector);
    
    let diameter = simplex.diameter();
    println!("Complex diameter: {}", diameter);
    
    let fund_group_rank = simplex.fundamental_group_rank();
    println!("Fundamental group rank: {}", fund_group_rank);

    // 6. Spectral Sequences
    println!("\n6. Spectral Sequences:");
    let spectral_seq = betti_computer.spectral_sequence().map_err(|e| StateSpaceError::InvalidOperation(e.to_string()))?;
    println!("Spectral sequence converges: {}", spectral_seq.converges());
    
    // Show some E2 page entries
    println!("E2 page entries:");
    for p in 0..=2 {
        for q in 0..=2 {
            let rank = spectral_seq.e2_rank(p, q);
            if rank > 0 {
                println!("  E2({},{}) = {}", p, q, rank);
            }
        }
    }

    // 7. Homological Algebra Integration
    println!("\n7. Homological Algebra Integration:");
    let _homology_groups = betti_computer.homology_groups(max_dim).map_err(|e| StateSpaceError::InvalidOperation(e.to_string()))?;
    println!("Homology groups computed for dimensions 0 to {}", max_dim);
    
    // The homology groups contain the full topological information
    println!("Homology provides complete topological invariants");
    println!("Betti numbers capture the 'holes' in each dimension");
    
    println!("\nTopological analysis reveals the geometric structure of factorization spaces!");
    
    Ok(())
}