ppflib 0.1.0

//! Geometric Structures in PPF
//!
//! This example explores the geometric aspects of PPF:
//! - IOT (Involuted Oblate Toroidal) metric
//! - PPF Hilbert space construction
//! - Quantum operators and geometric realizations

use ppflib::prelude::*;
use ppflib::geometry::IOTCoordinates;
use ppflib::core::StateSpaceError;

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

    // 1. IOT Metric and Geometry
    println!("1. IOT (Involuted Oblate Toroidal) Metric:");
    let iot_metric = IOTMetric::new();
    
    println!("IOT metric properties:");
    println!("  Major radius R: {}", iot_metric.major_radius());
    println!("  Minor radius r: {}", iot_metric.minor_radius());
    println!("  Critical ratio r/R: {}", iot_metric.critical_ratio());
    println!("  Is critical: {}", iot_metric.is_critical());
    
    // Show metric tensor components using IOTCoordinates
    let coords = IOTCoordinates::new(0.5, 1.0, 0.0).map_err(|e| StateSpaceError::InvalidOperation(e.to_string()))?;
    let metric_tensor = iot_metric.metric_tensor(&coords);
    println!("  Metric tensor at (0.5, 1.0, 0.0):");
    println!("    g_φφ = {}", metric_tensor.g_phi_phi);
    println!("    g_θθ = {}", metric_tensor.g_theta_theta);
    println!("    g_ψψ = {}", metric_tensor.g_psi_psi);
    
    // Show additional coordinate examples
    let coords1 = IOTCoordinates::new(0.0, 0.0, 0.0).map_err(|e| StateSpaceError::InvalidOperation(e.to_string()))?;
    let coords2 = IOTCoordinates::new(1.0, 0.5, 0.1).map_err(|e| StateSpaceError::InvalidOperation(e.to_string()))?;
    println!("  Coordinate examples created successfully");
    
    // Warping function
    let warping = iot_metric.warping_function(&coords);
    println!("  Warping function W(φ,θ,ψ): {}", warping);

    // 2. Tautochrone Operators
    println!("\n2. Tautochrone Operators:");
    let state_space = FactorizationStateSpace::new(12).map_err(|e| StateSpaceError::InvalidOperation(e.to_string()))?;
    let tautochrone = TautochroneOperator::new(iot_metric.clone());
    
    println!("Tautochrone operator properties:");
    println!("  Operator constructed on IOT metric");
    
    // Check for geodesic properties
    let geodesic_path = tautochrone.geodesic(&coords1, &coords2).map_err(|e| StateSpaceError::InvalidOperation(e.to_string()))?;
    println!("  Geodesic computed between points");
    
    // Parallel transport along the geodesic
    let test_vector_coords = IOTCoordinates::new(0.1, 0.2, 0.0).map_err(|e| StateSpaceError::InvalidOperation(e.to_string()))?;
    let transported = tautochrone.parallel_transport(&geodesic_path, &test_vector_coords).map_err(|e| StateSpaceError::InvalidOperation(e.to_string()))?;
    println!("  Parallel transport completed");

    // 3. PPF Hilbert Space
    println!("\n3. PPF Hilbert Space:");
    let hilbert_space = PPFHilbertSpace::new(state_space.clone());
    
    println!("Hilbert space properties:");
    println!("  Dimension: {}", hilbert_space.dimension());
    
    // Create quantum states
    // Create some test quantum states using available constructors
    let test_state1 = QuantumState::uniform_superposition(&state_space).map_err(|e| StateSpaceError::InvalidOperation(e.to_string()))?;
    let test_state2 = QuantumState::uniform_superposition(&state_space).map_err(|e| StateSpaceError::InvalidOperation(e.to_string()))?;
    
    println!("  Test state 1 dimension: {}", test_state1.dimension());
    println!("  Test state 2 dimension: {}", test_state2.dimension());
    
    // Inner product
    let inner_product = hilbert_space.inner_product(&test_state1, &test_state2);
    println!("  Inner product <ψ₁|ψ₂>: {}", inner_product);

    // 4. Quantum Operators
    println!("\n4. Quantum Operators:");
    
    // Use the sign operator which is the main quantum operator available
    let sign_op = hilbert_space.sign_operator();
    println!("Sign operator properties:");
    println!("  Operator dimension: {}x{}", sign_op.dimension(), sign_op.dimension());
    
    // Apply sign operator to test state
    let sign_result = sign_op.apply(&test_state1).map_err(|e| StateSpaceError::InvalidOperation(e.to_string()))?;
    println!("  Ŝ|ψ⟩ norm: {}", sign_result.norm());
    
    // Show operator properties
    println!("  Sign operator matrix dimensions: {}x{}", sign_op.dimension(), sign_op.dimension());

    // 5. Geometric Realizations
    println!("\n5. Geometric Realizations:");
    
    // Embed factorizations in geometric space
    let factorizations = state_space.factorizations();
    println!("Embedding {} factorizations in IOT space", factorizations.len());
    
    for (i, factorization) in factorizations.iter().enumerate() {
        // Map factorization to IOT coordinates
        let phi = (i as f64) / (factorizations.len() as f64) * 2.0 * std::f64::consts::PI;
        let theta = factorization.complexity() as f64 / 10.0;
        let psi = if factorization.has_sign_prime() { 1.0 } else { 0.0 };
        
        if let Ok(iot_coords) = IOTCoordinates::new(phi, theta, psi) {
            let metric_at_point = iot_metric.metric_tensor(&iot_coords);
            
            println!("  Factorization {}: {} → IOT({:.2}, {:.2}, {:.2})", 
                    i, factorization, phi, theta, psi);
            println!("    Metric components: g_φφ={:.3}, g_θθ={:.3}, g_ψψ={:.3}", 
                    metric_at_point.g_phi_phi, metric_at_point.g_theta_theta, metric_at_point.g_psi_psi);
        }
    }
    
    // Warping analysis
    let warping_test = iot_metric.warping_function(&coords);
    println!("  Warping function at test point: {}", warping_test);

    // 6. Advanced Hilbert Space Features
    println!("\n6. Advanced Hilbert Space Features:");
    
    // Inner product computations
    let inner_product_magnitude = hilbert_space.inner_product(&test_state1, &test_state2).norm();
    println!("Inner product magnitude: {}", inner_product_magnitude);
    
    // Test state properties
    println!("Test state 1 norm: {}", test_state1.norm());
    println!("Test state 1 is normalized: {}", test_state1.is_normalized());
    
    // Sign operator applications
    let sign_applied = sign_op.apply(&test_state1).map_err(|e| StateSpaceError::InvalidOperation(e.to_string()))?;
    println!("Sign operator preserves norm: {}", (sign_applied.norm() - test_state1.norm()).abs() < 1e-10);

    // 7. Geometric Properties
    println!("\n7. Geometric Properties:");
    
    // Basic metric properties
    println!("IOT metric analysis:");
    println!("  Critical ratio achieved: {}", iot_metric.is_critical());
    println!("  Major/minor radius ratio: {:.6}", iot_metric.major_radius() / iot_metric.minor_radius());
    
    // Coordinate system properties
    println!("  Coordinate system provides toroidal embedding");
    
    // Warping behavior
    let origin = IOTCoordinates::new(0.0, 0.0, 0.0).map_err(|e| StateSpaceError::InvalidOperation(e.to_string()))?;
    let warping_origin = iot_metric.warping_function(&origin);
    println!("  Warping at origin: {}", warping_origin);
    
    println!("\nGeometric structures provide the continuous framework for discrete PPF operations!");
    
    Ok(())
}