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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

//! Algebraic Structures in PPF
//!
//! This example explores the advanced algebraic concepts:
//! - State space ideals IS(n)
//! - P-prime spectrum
//! - Multiplication algebra
//! - Homological algebra

use ppflib::prelude::*;
use ppflib::algebra::StateSpaceIdealError;

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

    // 1. State Space Ideals
    println!("1. State Space Ideals:");
    let ideal_12 = StateSpaceIdeal::new(12)?;
    let ideal_neg12 = StateSpaceIdeal::new(-12)?;
    
    println!("IS(12) generator: {}", ideal_12.generator());
    println!("IS(-12) generator: {}", ideal_neg12.generator());
    println!("IS(12) dimension: {}", ideal_12.dimension());
    println!("IS(-12) dimension: {}", ideal_neg12.dimension());
    
    // Check quantum vs classical
    println!("IS(12) is classical: {}", ideal_12.is_classical());
    println!("IS(-12) is quantum: {}", ideal_neg12.is_quantum());
    
    // Show ideal properties
    println!("IS(12) contains 24: {}", ideal_12.contains(24));
    println!("IS(12) contains 7: {}", ideal_12.contains(7));

    // 2. P-Prime Spectrum
    println!("\n2. P-Prime Spectrum:");
    let spectrum = PPrimeSpectrum::new(100); // Prime bound
    let state_space = FactorizationStateSpace::new(30)?; // 2×3×5
    
    println!("Number of spectrum points: {}", spectrum.all_points().len());
    let magnitude_primes = spectrum.magnitude_prime_points();
    println!("Magnitude prime points: {}", magnitude_primes.len());
    
    // Analyze spectrum structure
    let sign_prime_point = spectrum.sign_prime_point();
    println!("Sign prime point: {}", sign_prime_point.prime());
    println!("  Is sign prime: {}", sign_prime_point.is_sign_prime());
    
    // Check support
    let support = spectrum.support(&state_space);
    println!("Support of S(30): {:?}", support);

    // 3. Multiplication Algebra
    println!("\n3. Multiplication Algebra:");
    let _mult_algebra = MultiplicationAlgebra::new();
    
    // Create some test states
    let s6 = FactorizationStateSpace::new(6)?;
    let s10 = FactorizationStateSpace::new(10)?;
    let s15 = FactorizationStateSpace::new(15)?;
    
    println!("Computing multiplication properties:");
    println!("S(6) size: {}", s6.size());
    println!("S(10) size: {}", s10.size());
    println!("S(15) size: {}", s15.size());
    
    // Check if states have disjoint support
    println!("S(6) and S(10) have disjoint support: {}", 
             spectrum.have_disjoint_support(&s6, &s10));

    // 4. Homological Algebra
    println!("\n4. Homological Algebra:");
    let _homology = HomologyGroups::new();
    
    // Show homology group structure
    println!("Homology groups structure initialized");
    println!("Can compute chain complexes and Betti numbers");
    
    // The actual computation would require more complex setup
    // For now, show the theoretical structure
    println!("For S(30) with 3 distinct primes:");
    println!("  Expected b₁ = 2 (from 3-1 primes)");
    println!("  Expected χ = 0 (toroidal topology)");

    // 5. Algebraic Operations
    println!("\n5. Advanced Algebraic Operations:");
    
    // Ideal operations
    let ideal_6 = StateSpaceIdeal::new(6)?;
    let ideal_10 = StateSpaceIdeal::new(10)?;
    
    if let Ok(sum) = ideal_6.add(&ideal_10) {
        println!("IS(6) + IS(10) = IS({})", sum.generator());
    }
    
    if let Ok(product) = ideal_6.multiply(&ideal_10) {
        println!("IS(6) × IS(10) = IS({})", product.generator());
    }
    
    if let Ok(intersection) = ideal_6.intersect(&ideal_10) {
        println!("IS(6) ∩ IS(10) = IS({})", intersection.generator());
    }

    // Containment
    println!("IS(6) contains IS(12): {}", ideal_6.contains_ideal(&StateSpaceIdeal::new(12)?));
    println!("IS(12) contains IS(6): {}", StateSpaceIdeal::new(12)?.contains_ideal(&ideal_6));

    // 6. Ring Structure Analysis
    println!("\n6. Ring Structure Analysis:");
    println!("State space ideals form a ring under addition and multiplication");
    
    // Show some ring properties
    let ideal_1 = StateSpaceIdeal::new(1)?;
    println!("IS(1) generator: {}", ideal_1.generator());
    println!("IS(1) dimension: {}", ideal_1.dimension());
    
    // Commutativity check
    if let (Ok(ab), Ok(ba)) = (ideal_6.multiply(&ideal_10), ideal_10.multiply(&ideal_6)) {
        println!("Multiplication is commutative: {}", ab.generator() == ba.generator());
    }

    // 7. Localization
    println!("\n7. Localization at Primes:");
    if let Some(_point_2) = spectrum.get_point(2) {
        println!("Localizing S(30) at prime 2:");
        if let Ok(localized) = spectrum.localize(&state_space, 2) {
            println!("  Local dimension: {}", localized.local_dimension());
            println!("  Is trivial: {}", localized.is_trivial());
        }
    }

    println!("\nAlgebraic structures provide the foundation for quantum-classical transitions!");
    
    Ok(())
}