mathhook_core/functions/polynomials/
laguerre.rs

1//! Laguerre Polynomial Intelligence
2//!
3//! Mathematically accurate implementation of Laguerre polynomials L_n(x)
4//! for hydrogen atom radial wavefunctions with verified properties.
5
6use crate::core::{Expression, Symbol};
7use crate::functions::properties::*;
8use std::collections::HashMap;
9use std::sync::Arc;
10
11/// Laguerre Polynomial Intelligence
12///
13/// Complete mathematical intelligence for Laguerre polynomials L_n(x)
14pub struct LaguerreIntelligence {
15    /// Function properties for Laguerre polynomials
16    properties: HashMap<String, FunctionProperties>,
17}
18
19impl Default for LaguerreIntelligence {
20    fn default() -> Self {
21        Self::new()
22    }
23}
24
25impl LaguerreIntelligence {
26    /// Create new Laguerre polynomial intelligence system
27    pub fn new() -> Self {
28        let mut intelligence = Self {
29            properties: HashMap::with_capacity(4),
30        };
31
32        intelligence.initialize_laguerre_polynomials();
33
34        intelligence
35    }
36
37    /// Get all Laguerre polynomial properties
38    pub fn get_properties(&self) -> HashMap<String, FunctionProperties> {
39        self.properties.clone()
40    }
41
42    /// Check if function is a Laguerre polynomial
43    pub fn has_function(&self, name: &str) -> bool {
44        self.properties.contains_key(name)
45    }
46
47    /// Initialize Laguerre polynomials with ABSOLUTE MATHEMATICAL ACCURACY
48    fn initialize_laguerre_polynomials(&mut self) {
49        // Laguerre Polynomials L_n(x) - MATHEMATICALLY VERIFIED
50        // Reference: Quantum Mechanics, Atomic Physics textbooks
51        // Used for hydrogen atom radial wavefunctions
52        self.properties.insert(
53            "laguerre".to_owned(),
54            FunctionProperties::Polynomial(Box::new(PolynomialProperties {
55
56                family: PolynomialFamily::Laguerre,
57
58                // THREE-TERM RECURRENCE RELATION (MATHEMATICALLY VERIFIED)
59                // (n+1)L_{n+1}(x) = (2n+1-x)L_n(x) - nL_{n-1}(x)
60                recurrence: ThreeTermRecurrence {
61                    // Coefficient structure for Laguerre recurrence
62                    alpha_coeff: Expression::function(
63                        "laguerre_alpha",
64                        vec![Expression::symbol("n")],
65                    ),
66                    beta_coeff: Expression::function(
67                        "laguerre_beta",
68                        vec![Expression::symbol("n")],
69                    ),
70                    gamma_coeff: Expression::function(
71                        "laguerre_gamma",
72                        vec![Expression::symbol("n")],
73                    ),
74
75                    // Initial conditions (mathematically verified)
76                    // L_0(x) = 1, L_1(x) = 1 - x
77                    initial_conditions: (
78                        Expression::integer(1),
79                        Expression::add(vec![
80                            Expression::integer(1),
81                            Expression::mul(vec![Expression::integer(-1), Expression::symbol("x")]),
82                        ]),
83                    ),
84                },
85
86                // Orthogonality properties (mathematically verified)
87                // ∫_0^∞ L_m(x) L_n(x) e^{-x} dx = δ_{mn}
88                orthogonality: Some(OrthogonalityData {
89                    // Weight function: w(x) = e^{-x}
90                    weight_function: Expression::function(
91                        "exp",
92                        vec![Expression::mul(vec![
93                            Expression::integer(-1),
94                            Expression::symbol("x"),
95                        ])],
96                    ),
97
98                    // Orthogonality interval: [0, ∞)
99                    interval: (Expression::integer(0), Expression::symbol("∞")),
100
101                    // Normalization: ||L_n||² = 1
102                    norm_squared: Expression::integer(1),
103                }),
104
105                // Rodrigues' formula (mathematically verified)
106                // L_n(x) = (e^x/n!) d^n/dx^n (x^n e^{-x})
107                rodrigues_formula: Some(RodriguesFormula {
108                    formula: "L_n(x) = (e^x/n!) d^n/dx^n (x^n e^{-x})".to_owned(),
109                    normalization: Expression::function(
110                        "laguerre_rodrigues_norm",
111                        vec![Expression::symbol("n")],
112                    ),
113                    weight_function: Expression::function(
114                        "laguerre_rodrigues_weight",
115                        vec![Expression::symbol("n"), Expression::symbol("x")],
116                    ),
117                }),
118
119                // Generating function (mathematically verified)
120                // 1/(1-t) exp(-xt/(1-t)) = Σ_{n=0}^∞ L_n(x) t^n
121                generating_function: Some(GeneratingFunction {
122                    function: Expression::function(
123                        "laguerre_generating",
124                        vec![Expression::symbol("x"), Expression::symbol("t")],
125                    ),
126                    gf_type: GeneratingFunctionType::Ordinary,
127                }),
128
129                // Special values (mathematically verified)
130                special_values: vec![
131                    // L_n(0) = 1 for all n ≥ 0
132                    SpecialValue {
133                        input: "0".to_owned(),
134                        output: Expression::integer(1),
135                        latex_explanation: "L_n(0) = 1 \\text{ for all } n \\geq 0".to_owned(),
136                    },
137                ],
138
139                // Evaluation method: Recurrence is most numerically stable
140                evaluation_method: EvaluationMethod::Recurrence,
141
142                // Numerical evaluator using recurrence relation),
143
144                // Symbolic expansion method for intelligence-driven computation
145                symbolic_expander: Some(super::super::properties::special::SymbolicExpander::Custom(
146                    super::symbolic::expand_laguerre_symbolic
147                )),
148
149                antiderivative_rule: AntiderivativeRule {
150                    rule_type: AntiderivativeRuleType::Custom {
151                        builder: Arc::new(|var: Symbol| {
152                            Expression::integral(
153                                Expression::function("laguerre", vec![Expression::symbol(var.clone())]),
154                                var
155                            )
156                        }),
157                    },
158                    result_template: "∫L_n(x) dx (symbolic - orthogonal polynomial integration requires specialized techniques)".to_owned(),
159                    constant_handling: ConstantOfIntegration::AddConstant,
160                },
161                wolfram_name: None,
162            })),
163        );
164    }
165}
mathhook_core/functions/polynomials/laguerre.rs

mathhook_core/functions/polynomials/
laguerre.rs
