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

//! # PPF (Physics-Prime Factorization) Library
//!
//! A comprehensive Rust library implementing the Physics-Prime Factorization (PPF) 
//! mathematical framework for exploring quantum mechanics through number theory.
//!
//! ## Overview
//!
//! The PPF framework extends classical number theory by treating -1 as a special 
//! "Sign Prime", creating multiple valid factorizations for integers and enabling
//! a number-theoretic model of quantum phenomena.
//!
//! ## Quick Start
//!
//! ```rust
//! use ppflib::prelude::*;
//!
//! // Create factorization state spaces
//! let state = FactorizationStateSpace::new(6)?;     // Classical state (positive)
//! let quantum = FactorizationStateSpace::new(-6)?;  // Quantum state (negative)
//!
//! println!("S(6) has {} factorizations", state.size());
//! println!("S(-6) has {} factorizations", quantum.size());
//!
//! // Demonstrate quantum collapse: (-2) × (-3) = 6
//! let s_neg2 = FactorizationStateSpace::new(-2)?;
//! let s_neg3 = FactorizationStateSpace::new(-3)?;
//! let result = s_neg2.multiply(&s_neg3)?;
//!
//! if result.collapse_info.collapsed {
//!     println!("Quantum collapse occurred!");
//! }
//! # Ok::<(), ppflib::core::FactorizationError>(())
//! ```
//!
//! ## Feature Overview
//!
//! ### Core Features
//! - **Factorization State Spaces**: Complete enumeration of valid P-factorizations
//! - **Quantum Collapse**: Modeling (-a) × (-b) = ab transitions
//! - **Sign Prime**: The unique negative prime (-1) enabling quantum behavior
//!
//! ### Advanced Features
//! - **Algebraic Structures**: State space ideals, P-prime spectrum, homology
//! - **Topological Analysis**: Simplicial complexes, Galois groups, Betti numbers
//! - **Geometric Realizations**: IOT metric, tautochrone operators, Hilbert spaces
//!
//! ## Module Organization
//!
//! - [`prelude`]: Common imports for most use cases
//! - [`core`]: Fundamental PPF primitives and operations
//! - [`algebra`]: Advanced algebraic structures
//! - [`topology`]: Topological properties of state spaces
//! - [`geometry`]: Geometric realizations and IOT framework

#![deny(missing_docs)]
#![warn(rust_2018_idioms)]
#![allow(clippy::module_name_repetitions)]

// Module structure - expose existing modules with better organization
pub mod core;
pub mod algebra;
pub mod topology;
pub mod geometry;

/// Prelude - common imports for convenience
pub mod prelude {
    //! Common imports for most PPF use cases
    
    // Core types
    pub use crate::core::{
        FactorizationStateSpace, PFactorization, PPrime, SignPrime,
        StateSpaceOperations, CollapseInfo,
        FactorizationError,
    };
    
    // Algebraic types
    pub use crate::algebra::{
        StateSpaceIdeal, PPrimeSpectrum, MultiplicationAlgebra,
        HomologyGroups,
    };
    
    // Topological types
    pub use crate::topology::{
        FactorizationSimplex, PPFGaloisGroup, BettiNumberComputer,
        Vertex, Edge, Face, TopologicalType,
    };
    
    // Geometric types
    pub use crate::geometry::{
        IOTMetric, TautochroneOperator, PPFHilbertSpace,
        QuantumState, QuantumOperator,
    };
    
    // Constants
    pub use crate::{VERSION, DESCRIPTION, CRITICAL_RATIO};
}

/// Core factorization functionality
pub use core::{
    FactorizationStateSpace as StateSpace,
    PFactorization as Factorization,
    FactorizationError as Error,
};

/// Library version information
pub const VERSION: &str = env!("CARGO_PKG_VERSION");

/// Library description
pub const DESCRIPTION: &str = env!("CARGO_PKG_DESCRIPTION");

/// The critical IOT ratio r/R = 1/30
pub const CRITICAL_RATIO: f64 = 1.0 / 30.0;