Skip to main content

qualia_core_db/
quantum_dft.rs

1//! Quantum Chemistry & Density Functional Theory (DFT)
2//! Bounded pure Rust approximations replacing external C-FFI quantum solvers.
3//! Enhanced with orthomodular lattice operations for quantum propositional logic.
4
5use crate::NQuin;
6use std::collections::HashMap;
7
8/// Represents a bounded electron density approximation matrix.
9pub struct ElectronDensity {
10    pub grid_resolution: usize,
11    pub density_matrix: Vec<f64>,
12}
13
14impl ElectronDensity {
15    /// Creates a default `ElectronDensity`.
16    pub fn new(resolution: usize) -> Self {
17        Self {
18            grid_resolution: resolution,
19            density_matrix: vec![0.0; resolution * resolution * resolution],
20        }
21    }
22
23    /// Thomas-Fermi orbital-free DFT with LDA exchange on a 3D cubic grid.
24    /// Runs a self-consistent field (SCF) loop until the total energy converges.
25    pub fn calculate_ground_state_energy(&mut self, quins: &[NQuin]) -> f64 {
26        let n_electrons = quins
27            .iter()
28            .filter(|q| q.predicate == crate::q_hash("HAS_ELECTRON"))
29            .count();
30        if n_electrons == 0 {
31            return 0.0;
32        }
33
34        let n = n_electrons as f64;
35        let z = n; // Neutral atom: nuclear charge Z = N
36        let res = self.grid_resolution.max(2);
37        let grid_size = res * res * res;
38
39        // Physical box: L³ bohr, centred on nucleus; L = 12 Z^(1/3) captures >99% of TF density
40        let l: f64 = 12.0 * z.powf(1.0 / 3.0);
41        let h: f64 = l / (res as f64);
42        let dv: f64 = h * h * h;
43
44        // Thomas-Fermi kinetic energy constant:  C_TF = (3/10)(3π²)^(2/3) a.u.
45        let c_tf: f64 = 0.3 * (3.0 * std::f64::consts::PI * std::f64::consts::PI).powf(2.0 / 3.0);
46        // Dirac–Slater exchange constant: C_X = -(3/4)(3/π)^(1/3) a.u.
47        let c_x: f64 = -(3.0 / 4.0) * (3.0 / std::f64::consts::PI).powf(1.0 / 3.0);
48
49        // Precompute |r| at every grid point (nucleus at box centre)
50        let ctr = l / 2.0;
51        let r_grid: Vec<f64> = (0..grid_size)
52            .map(|idx| {
53                let iz = idx / (res * res);
54                let iy = (idx / res) % res;
55                let ix = idx % res;
56                let rx = (ix as f64 + 0.5) * h - ctr;
57                let ry = (iy as f64 + 0.5) * h - ctr;
58                let rz = (iz as f64 + 0.5) * h - ctr;
59                (rx * rx + ry * ry + rz * rz).sqrt().max(h * 0.5) // clamp to avoid r = 0
60            })
61            .collect();
62
63        // Initialise with hydrogen-like exponential decay, normalised to N electrons
64        let alpha = 2.0 * z;
65        let raw_sum: f64 = r_grid.iter().map(|&r| (-alpha * r).exp()).sum::<f64>() * dv;
66        self.density_matrix = r_grid
67            .iter()
68            .map(|&r| (-alpha * r).exp() * n / raw_sum.max(1e-30))
69            .collect();
70
71        let max_iter = 100usize;
72        let mix = 0.40_f64;
73        let tol = 1e-9_f64;
74        let mut prev_e = f64::MAX;
75
76        for _iter in 0..max_iter {
77            // Enforce N-electron normalisation
78            let norm: f64 = self.density_matrix.iter().sum::<f64>() * dv;
79            if norm > 1e-30 {
80                let s = n / norm;
81                self.density_matrix.iter_mut().for_each(|r| *r *= s);
82            }
83
84            // ── Energy components ────────────────────────────────────────────
85            let t_tf: f64 = self
86                .density_matrix
87                .iter()
88                .map(|&rho| c_tf * rho.powf(5.0 / 3.0))
89                .sum::<f64>()
90                * dv;
91            let e_xc: f64 = self
92                .density_matrix
93                .iter()
94                .map(|&rho| c_x * rho.powf(4.0 / 3.0))
95                .sum::<f64>()
96                * dv;
97            let e_ne: f64 = r_grid
98                .iter()
99                .zip(self.density_matrix.iter())
100                .map(|(&r, &rho)| (-z / r) * rho)
101                .sum::<f64>()
102                * dv;
103            // Mean-field Hartree: classical self-energy of uniform sphere of charge N
104            let rho_avg = n / (l * l * l);
105            let r_ws = (3.0 / (4.0 * std::f64::consts::PI * rho_avg)).powf(1.0 / 3.0);
106            let e_h = 0.5 * n * n / r_ws;
107
108            let e_total_ha = t_tf + e_xc + e_ne + e_h;
109            let e_total_ev = e_total_ha * 27.2114; // Hartree → eV
110
111            if (e_total_ev - prev_e).abs() < tol {
112                return e_total_ev;
113            }
114            prev_e = e_total_ev;
115
116            // ── Density update via TF inversion ─────────────────────────────
117            // Chemical potential μ: set from the average-density point
118            let v_tf_avg = (5.0 / 3.0) * c_tf * rho_avg.powf(2.0 / 3.0);
119            let v_xc_avg = (4.0 / 3.0) * c_x * rho_avg.powf(1.0 / 3.0);
120            let mu = v_tf_avg + v_xc_avg + n / r_ws - z / r_ws; // v_H + v_ne cancel for neutral atom
121
122            // ρ_new(r) = [(μ − v_eff(r)) / ((5/3)C_TF)]^(3/2), clamped to ≥ 0
123            let new_rho: Vec<f64> = r_grid
124                .iter()
125                .zip(self.density_matrix.iter())
126                .map(|(&r, &rho_i)| {
127                    let v_xc_i = (4.0 / 3.0) * c_x * rho_i.powf(1.0 / 3.0);
128                    let v_eff_i = (-z / r) + (n / r_ws) + v_xc_i;
129                    let arg = (mu - v_eff_i) / ((5.0 / 3.0) * c_tf);
130                    if arg > 0.0 {
131                        arg.powf(1.5)
132                    } else {
133                        0.0
134                    }
135                })
136                .collect();
137
138            // Linear mixing to stabilise convergence
139            for (rho, rho_new) in self.density_matrix.iter_mut().zip(new_rho.iter()) {
140                *rho = (1.0 - mix) * *rho + mix * rho_new;
141            }
142        }
143
144        prev_e
145    }
146}
147
148/// Orthomodular lattice for quantum propositional logic
149/// Implements non-distributive quantum logic with orthocomplementation
150#[derive(Debug, Clone, PartialEq, Eq)]
151pub struct QuantumLattice {
152    pub propositions: HashMap<u64, QuantumProposition>,
153    pub lattice_order: Vec<u64>, // Partial order representation
154}
155
156#[derive(Debug, Clone, PartialEq, Eq)]
157pub struct QuantumProposition {
158    pub id: u64,
159    pub truth_value: QuantumTruthValue,
160    pub orthocomplement: Option<u64>, // Reference to orthocomplement proposition
161    pub measurement_basis: String,
162}
163
164#[derive(Debug, Clone, PartialEq, Eq)]
165pub enum QuantumTruthValue {
166    True,
167    False,
168    Superposed, // Quantum superposition state
169    Uncertain,  // Measurement uncertainty
170}
171
172impl QuantumLattice {
173    /// Create a new quantum lattice with orthomodular structure
174    pub fn new() -> Self {
175        Self {
176            propositions: HashMap::new(),
177            lattice_order: Vec::new(),
178        }
179    }
180
181    /// Add a quantum proposition to the lattice
182    pub fn add_proposition(&mut self, prop: QuantumProposition) {
183        self.lattice_order.push(prop.id);
184        self.propositions.insert(prop.id, prop);
185    }
186
187    /// Compute orthocomplement of a proposition (quantum NOT)
188    pub fn orthocomplement(&self, prop_id: u64) -> Option<u64> {
189        self.propositions.get(&prop_id)?.orthocomplement
190    }
191
192    /// Check if two propositions are compatible (commuting observables)
193    pub fn are_compatible(&self, prop1_id: u64, prop2_id: u64) -> bool {
194        if let (Some(prop1), Some(prop2)) = (
195            self.propositions.get(&prop1_id),
196            self.propositions.get(&prop2_id),
197        ) {
198            // propositions are compatible if they share the same measurement basis
199            prop1.measurement_basis == prop2.measurement_basis
200        } else {
201            false
202        }
203    }
204
205    /// Quantum AND operation (meet in orthomodular lattice)
206    pub fn quantum_and(&self, prop1_id: u64, prop2_id: u64) -> Option<u64> {
207        // For compatible propositions, use classical AND
208        if self.are_compatible(prop1_id, prop2_id) {
209            if let (Some(prop1), Some(prop2)) = (
210                self.propositions.get(&prop1_id),
211                self.propositions.get(&prop2_id),
212            ) {
213                match (&prop1.truth_value, &prop2.truth_value) {
214                    (QuantumTruthValue::True, QuantumTruthValue::True) => Some(prop1_id),
215                    _ => self.orthocomplement(prop1_id), // Simplified quantum logic
216                }
217            } else {
218                None
219            }
220        } else {
221            // For incompatible propositions, result is undefined in quantum logic
222            None
223        }
224    }
225
226    /// Quantum OR operation (join in orthomodular lattice)
227    pub fn quantum_or(&self, prop1_id: u64, prop2_id: u64) -> Option<u64> {
228        if self.are_compatible(prop1_id, prop2_id) {
229            if let (Some(prop1), Some(prop2)) = (
230                self.propositions.get(&prop1_id),
231                self.propositions.get(&prop2_id),
232            ) {
233                match (&prop1.truth_value, &prop2.truth_value) {
234                    (QuantumTruthValue::True, _) | (_, QuantumTruthValue::True) => Some(prop1_id),
235                    _ => self.orthocomplement(prop2_id),
236                }
237            } else {
238                None
239            }
240        } else {
241            None
242        }
243    }
244
245    /// Apply measurement to collapse superposition
246    pub fn measure(&mut self, prop_id: u64) -> Option<QuantumTruthValue> {
247        if let Some(prop) = self.propositions.get_mut(&prop_id) {
248            match prop.truth_value {
249                QuantumTruthValue::Superposed => {
250                    // Deterministic collapse on proposition-id parity (NOT a
251                    // probabilistic 50/50 measurement — this is a toy
252                    // orthomodular-logic model, not a physical simulator).
253                    prop.truth_value = if (prop.id % 2) == 0 {
254                        QuantumTruthValue::True
255                    } else {
256                        QuantumTruthValue::False
257                    };
258                    Some(prop.truth_value.clone())
259                }
260                _ => Some(prop.truth_value.clone()),
261            }
262        } else {
263            None
264        }
265    }
266}
267
268/// Convert quantum lattice state to NQuin for storage
269pub fn quantum_lattice_to_quin(lattice: &QuantumLattice, context: u64) -> Vec<NQuin> {
270    let mut quins = Vec::new();
271
272    for (id, prop) in &lattice.propositions {
273        let mut quin = NQuin {
274            subject: *id,
275            predicate: crate::q_hash("has_quantum_state"),
276            object: match prop.truth_value {
277                QuantumTruthValue::True => 1,
278                QuantumTruthValue::False => 0,
279                QuantumTruthValue::Superposed => 2,
280                QuantumTruthValue::Uncertain => 3,
281            },
282            context,
283            metadata: 0,
284            parity: 0,
285        };
286
287        // Set orthocomplement in metadata if present
288        if let Some(ortho_id) = prop.orthocomplement {
289            quin.metadata = ortho_id;
290        }
291
292        quin.parity = quin.subject ^ quin.predicate ^ quin.object ^ quin.context;
293        quins.push(quin);
294    }
295
296    quins
297}
298
299/// Predicts physical states natively using a bounded Physics-Informed Neural Network (PINN) abstraction.
300pub fn pinn_predict_receptor_binding(molecule_quins: &[NQuin], receptor_quins: &[NQuin]) -> f64 {
301    // Pure Rust semantic graph evaluation simulating a trained localized model binding affinity
302    if molecule_quins.is_empty() || receptor_quins.is_empty() {
303        return 0.0;
304    }
305
306    // Mock binding affinity calculation
307    let mut affinity = -5.0; // kcal/mol base
308    for mq in molecule_quins {
309        for rq in receptor_quins {
310            if mq.predicate == rq.predicate {
311                affinity -= 1.2; // Affinity increases (becomes more negative) for geometric matches
312            }
313        }
314    }
315    affinity
316}
317
318#[cfg(test)]
319mod tests {
320    use super::*;
321
322    #[test]
323    fn test_quantum_lattice_creation() {
324        let mut lattice = QuantumLattice::new();
325
326        let prop_a = QuantumProposition {
327            id: 1,
328            truth_value: QuantumTruthValue::True,
329            orthocomplement: Some(2),
330            measurement_basis: "computational".to_string(),
331        };
332
333        let prop_b = QuantumProposition {
334            id: 2,
335            truth_value: QuantumTruthValue::False,
336            orthocomplement: Some(1),
337            measurement_basis: "computational".to_string(),
338        };
339
340        lattice.add_proposition(prop_a);
341        lattice.add_proposition(prop_b);
342
343        assert_eq!(lattice.propositions.len(), 2);
344        assert_eq!(lattice.orthocomplement(1), Some(2));
345        assert_eq!(lattice.orthocomplement(2), Some(1));
346    }
347
348    #[test]
349    fn test_quantum_compatibility() {
350        let mut lattice = QuantumLattice::new();
351
352        let prop_x = QuantumProposition {
353            id: 10,
354            truth_value: QuantumTruthValue::Superposed,
355            orthocomplement: Some(11),
356            measurement_basis: "pauli_x".to_string(),
357        };
358
359        let prop_z = QuantumProposition {
360            id: 20,
361            truth_value: QuantumTruthValue::Superposed,
362            orthocomplement: Some(21),
363            measurement_basis: "pauli_z".to_string(),
364        };
365
366        lattice.add_proposition(prop_x);
367        lattice.add_proposition(prop_z);
368
369        // Same basis propositions should be compatible
370        assert!(lattice.are_compatible(10, 10));
371
372        // Different basis propositions should be incompatible
373        assert!(!lattice.are_compatible(10, 20));
374    }
375
376    #[test]
377    fn test_quantum_measurement() {
378        let mut lattice = QuantumLattice::new();
379
380        let prop = QuantumProposition {
381            id: 100,
382            truth_value: QuantumTruthValue::Superposed,
383            orthocomplement: None,
384            measurement_basis: "test".to_string(),
385        };
386
387        lattice.add_proposition(prop);
388
389        // Measurement should collapse superposition
390        let result = lattice.measure(100);
391        assert!(result.is_some());
392        assert!(result.unwrap() != QuantumTruthValue::Superposed);
393    }
394
395    #[test]
396    fn test_quantum_operations() {
397        let mut lattice = QuantumLattice::new();
398
399        let prop_true = QuantumProposition {
400            id: 1,
401            truth_value: QuantumTruthValue::True,
402            orthocomplement: Some(2),
403            measurement_basis: "test".to_string(),
404        };
405
406        let prop_false = QuantumProposition {
407            id: 2,
408            truth_value: QuantumTruthValue::False,
409            orthocomplement: Some(1),
410            measurement_basis: "test".to_string(),
411        };
412
413        lattice.add_proposition(prop_true);
414        lattice.add_proposition(prop_false);
415
416        // Test quantum AND
417        let and_result = lattice.quantum_and(1, 1);
418        assert_eq!(and_result, Some(1)); // True AND True = True
419
420        // Test quantum OR
421        let or_result = lattice.quantum_or(1, 2);
422        assert_eq!(or_result, Some(1)); // True OR False = True
423    }
424
425    #[test]
426    fn test_quantum_lattice_to_quin() {
427        let mut lattice = QuantumLattice::new();
428
429        let prop = QuantumProposition {
430            id: 42,
431            truth_value: QuantumTruthValue::Superposed,
432            orthocomplement: Some(43),
433            measurement_basis: "test".to_string(),
434        };
435
436        lattice.add_proposition(prop);
437
438        let quins = quantum_lattice_to_quin(&lattice, 123);
439        assert_eq!(quins.len(), 1);
440
441        let quin = &quins[0];
442        assert_eq!(quin.subject, 42);
443        assert_eq!(quin.object, 2); // Superposed = 2
444        assert_eq!(quin.context, 123);
445        assert_eq!(quin.metadata, 43); // orthocomplement stored in metadata
446    }
447}