ppflib 0.1.0

Advanced computational library for Physics-Prime Factorization (PPF): quantum mechanics through number theory, featuring Sign Prime (-1), state space collapse, topological analysis, and IOT geometric realizations
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

//! Basic PPF Factorization and Quantum Collapse
//!
//! This example demonstrates the core concepts of PPF:
//! - Creating factorization state spaces S(n)
//! - Understanding quantum vs classical states
//! - Observing quantum collapse during multiplication

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

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

    // Create classical state spaces (positive integers)
    println!("1. Classical State Spaces:");
    let s6 = FactorizationStateSpace::new(6)?;
    let s12 = FactorizationStateSpace::new(12)?;
    
    println!("S(6) has {} factorizations:", s6.size());
    for (i, factorization) in s6.factorizations().iter().enumerate() {
        println!("  {}: {}", i + 1, factorization);
    }
    
    println!("\nS(12) has {} factorizations:", s12.size());
    for (i, factorization) in s12.factorizations().iter().enumerate() {
        println!("  {}: {}", i + 1, factorization);
    }

    // Create quantum state spaces (negative integers)
    println!("\n2. Quantum State Spaces:");
    let s_neg6 = FactorizationStateSpace::new(-6)?;
    let s_neg12 = FactorizationStateSpace::new(-12)?;
    
    println!("S(-6) has {} factorizations:", s_neg6.size());
    for (i, factorization) in s_neg6.factorizations().iter().enumerate() {
        println!("  {}: {}", i + 1, factorization);
    }
    
    println!("\nS(-12) has {} factorizations:", s_neg12.size());
    for (i, factorization) in s_neg12.factorizations().iter().enumerate() {
        println!("  {}: {}", i + 1, factorization);
    }

    // Demonstrate quantum collapse: (-2) × (-3) = 6
    println!("\n3. Quantum Collapse Demonstration:");
    let s_neg2 = FactorizationStateSpace::new(-2)?;
    let s_neg3 = FactorizationStateSpace::new(-3)?;
    
    println!("Before multiplication:");
    println!("S(-2) has {} factorizations", s_neg2.size());
    println!("S(-3) has {} factorizations", s_neg3.size());
    
    // Use StateSpaceOperations to multiply
    let result = StateSpaceOperations::multiply(&s_neg2, &s_neg3)?;
    
    println!("\nAfter multiplication: S(-2) × S(-3)");
    println!("Result has {} factorizations", result.result_space.size());
    println!("Quantum collapse occurred: {}", result.collapse_info.collapsed);
    println!("Input sizes: {:?}", result.collapse_info.input_sizes);
    println!("Output size: {}", result.collapse_info.output_size);
    println!("Operation type: {:?}", result.collapse_info.operation_type);
    
    if result.collapse_info.collapsed {
        println!("✓ Quantum collapse: (-2) × (-3) → 6");
        println!("The negative factors combined and collapsed to classical state!");
    }

    // Compare with classical multiplication
    println!("\n4. Classical vs Quantum Multiplication:");
    let s2 = FactorizationStateSpace::new(2)?;
    let s3 = FactorizationStateSpace::new(3)?;
    let classical_result = StateSpaceOperations::multiply(&s2, &s3)?;
    
    println!("Classical: S(2) × S(3)");
    println!("Result has {} factorizations", classical_result.result_space.size());
    println!("Collapse occurred: {}", classical_result.collapse_info.collapsed);
    println!("Operation type: {:?}", classical_result.collapse_info.operation_type);

    // Show the Sign Prime in action
    println!("\n5. Sign Prime (-1) Analysis:");
    let s_neg1 = FactorizationStateSpace::new(-1)?;
    println!("S(-1) has {} factorizations:", s_neg1.size());
    for factorization in s_neg1.factorizations() {
        println!("  {}", factorization);
        println!("  Product: {}", factorization.value());
        println!("  Has sign prime: {}", factorization.has_sign_prime());
    }

    // Show specific factorization properties
    println!("\n6. Factorization Analysis:");
    println!("Analyzing S(6) factorizations:");
    for (i, factorization) in s6.factorizations().iter().enumerate() {
        println!("  Factorization {}: {}", i + 1, factorization);
        println!("    Value: {}", factorization.value());
        println!("    Has sign prime: {}", factorization.has_sign_prime());
        println!("    Distinct primes: {}", factorization.distinct_prime_count());
        println!("    Total factors: {}", factorization.total_factor_count());
        println!("    Complexity: {}", factorization.complexity());
    }
    
    Ok(())
}