1use qualia_core_db::solvers::linear_algebra::{
2 ConstTensorContractor, FixedLanczosEigensolver, Matrix4x4, StaticLuDecomposition, Tensor3x3x3,
3 Vector4,
4};
5use qualia_core_db::solvers::optimization::{
6 BoundedNewtonRaphson, CurveFitFunction, LevenbergMarquardtStack, NelderMeadSimplex,
7 ObjectiveFunction, RootFunction,
8};
9use qualia_core_db::solvers::quantum_optimizers::{
10 QAOAAngleOptimizer, QAOAAngles, QuantumCostFunction, SpsaCostFunction, SpsaOptimizer,
11};
12use qualia_core_db::solvers::symbolic_logic::{
13 BoundedSatSolver, Clause, DefeasibleRule, Fact, ForwardChainingDefeasible, Literal, RuleType,
14};
15use qualia_core_db::solvers::SolverConfig;
16
17fn parse_f64s(s: &str) -> Vec<f64> {
20 s.split(',')
21 .filter_map(|tok| tok.trim().parse::<f64>().ok())
22 .collect()
23}
24
25fn build_matrix4x4(v: &[f64]) -> Matrix4x4 {
26 let mut m = Matrix4x4::zero();
27 for row in 0..4 {
28 for col in 0..4 {
29 m.data[row][col] = v[row * 4 + col];
30 }
31 }
32 m
33}
34
35fn parse_matrix4x4(s: &str) -> Option<Matrix4x4> {
36 let v = parse_f64s(s);
37 if v.len() < 16 {
38 eprintln!(
39 "Need 16 comma-separated values for a 4×4 matrix, got {}.",
40 v.len()
41 );
42 return None;
43 }
44 Some(build_matrix4x4(&v))
45}
46
47fn parse_vector4(s: &str) -> Option<Vector4> {
48 let v = parse_f64s(s);
49 if v.len() < 4 {
50 eprintln!(
51 "Need 4 comma-separated values for a Vector4, got {}.",
52 v.len()
53 );
54 return None;
55 }
56 Some(Vector4::from_array([v[0], v[1], v[2], v[3]]))
57}
58
59fn build_tensor3x3x3(v: &[f64]) -> Tensor3x3x3 {
60 let mut t = Tensor3x3x3::zero();
61 for i in 0..3 {
62 for j in 0..3 {
63 for k in 0..3 {
64 t.data[i][j][k] = v[i * 9 + j * 3 + k];
65 }
66 }
67 }
68 t
69}
70
71fn parse_tensor3x3x3(s: &str) -> Option<Tensor3x3x3> {
72 let v = parse_f64s(s);
73 if v.len() < 27 {
74 eprintln!(
75 "Need 27 comma-separated values for a 3×3×3 tensor, got {}.",
76 v.len()
77 );
78 return None;
79 }
80 Some(build_tensor3x3x3(&v))
81}
82
83fn parse_params4(s: &str) -> Option<[f64; 4]> {
84 let v = parse_f64s(s);
85 if v.len() < 4 {
86 eprintln!("Need 4 comma-separated values, got {}.", v.len());
87 return None;
88 }
89 Some([v[0], v[1], v[2], v[3]])
90}
91
92fn default_config(max_iters: u32, tol: f64) -> SolverConfig {
93 SolverConfig {
94 max_iterations: max_iters,
95 tolerance: tol,
96 step_size: 0.01,
97 verbose: false,
98 }
99}
100
101pub fn run_matrix_multiply(a_str: &str, b_str: &str) {
105 let (Some(a), Some(b)) = (parse_matrix4x4(a_str), parse_matrix4x4(b_str)) else {
106 return;
107 };
108 let result = a.multiply_matrix(&b);
109 println!("Matrix A × B:");
110 print_matrix4x4(&result);
111}
112
113pub fn run_determinant(m_str: &str) {
115 let Some(m) = parse_matrix4x4(m_str) else {
116 return;
117 };
118 let det = m.determinant();
119 println!("Determinant: {det:.10e}");
120}
121
122pub fn run_solve_system(m_str: &str, v_str: &str) {
124 let (Some(a), Some(b)) = (parse_matrix4x4(m_str), parse_vector4(v_str)) else {
125 return;
126 };
127 let mut lu = StaticLuDecomposition::new(default_config(100, 1e-12));
128 match lu.solve(&a, &b) {
129 Ok(x) => {
130 println!("Solution x for Ax = b:");
131 println!(
132 " [{:.6}, {:.6}, {:.6}, {:.6}]",
133 x.data[0], x.data[1], x.data[2], x.data[3]
134 );
135 }
136 Err(e) => eprintln!("Solve failed: {e:?}"),
137 }
138}
139
140pub fn run_eigenvalues(m_str: &str, count: usize) {
142 let Some(m) = parse_matrix4x4(m_str) else {
143 return;
144 };
145 let mut solver = FixedLanczosEigensolver::new(default_config(100, 1e-8));
146 match solver.find_lowest_eigenvalues(&m, count) {
147 Ok(eigs) => {
148 let n = count.min(4);
149 println!("Lowest {n} eigenvalue(s) (Lanczos):");
150 for i in 0..n {
151 println!(" λ[{i}] = {:.10e}", eigs[i]);
152 }
153 }
154 Err(e) => eprintln!("Eigenvalue computation failed: {e:?}"),
155 }
156}
157
158pub fn run_tensor_contract(t_str: &str) {
160 let Some(ta) = parse_tensor3x3x3(t_str) else {
161 return;
162 };
163 let tb = Tensor3x3x3::zero();
164 let indices: [(usize, usize); 3] = [(0, 0), (1, 1), (2, 2)];
165 let mut contractor = ConstTensorContractor::new(default_config(1, 1e-10));
166 match contractor.contract(&ta, &tb, &indices) {
167 Ok(result) => {
168 let scalar: f64 = (0..3)
170 .flat_map(|i| (0..3).flat_map(move |j| (0..3).map(move |k| (i, j, k))))
171 .map(|(i, j, k)| result.data[i][j][k])
172 .sum();
173 println!("Tensor contraction A⊗0 trace-sum: {scalar:.10e}");
174 println!("(pass two tensors via --tensor-a and --tensor-b for a full contraction)");
175 }
176 Err(e) => eprintln!("Tensor contraction failed: {e:?}"),
177 }
178}
179
180fn print_matrix4x4(m: &Matrix4x4) {
181 for row in 0..4 {
182 println!(
183 " [{:12.6}, {:12.6}, {:12.6}, {:12.6}]",
184 m.data[row][0], m.data[row][1], m.data[row][2], m.data[row][3]
185 );
186 }
187}
188
189struct ClosureFn<F: Fn(&[f64; 4]) -> f64>(F);
192impl<F: Fn(&[f64; 4]) -> f64> ObjectiveFunction for ClosureFn<F> {
193 fn evaluate(&self, params: &[f64; 4]) -> f64 {
194 (self.0)(params)
195 }
196}
197
198struct RootClosureFn<F: Fn(f64) -> f64, D: Fn(f64) -> f64>(F, D);
199impl<F: Fn(f64) -> f64, D: Fn(f64) -> f64> RootFunction for RootClosureFn<F, D> {
200 fn evaluate(&self, x: f64) -> f64 {
201 (self.0)(x)
202 }
203 fn derivative(&self, x: f64) -> f64 {
204 (self.1)(x)
205 }
206}
207
208struct CurveFn;
209impl CurveFitFunction for CurveFn {
210 fn evaluate(&self, x: f64, p: &[f64; 4]) -> f64 {
212 p[0] * x.powi(3) + p[1] * x.powi(2) + p[2] * x + p[3]
213 }
214 fn jacobian(&self, x: f64, _p: &[f64; 4]) -> [f64; 4] {
215 [x.powi(3), x.powi(2), x, 1.0]
216 }
217}
218
219pub fn run_simplex(initial_str: &str, iterations: u32) {
223 let Some(x0) = parse_params4(initial_str) else {
224 return;
225 };
226 let cfg = default_config(iterations, 1e-8);
227 let mut solver = NelderMeadSimplex::new(x0, cfg);
228 let f = ClosureFn(|p: &[f64; 4]| {
230 let a = (1.0 - p[0]).powi(2) + 100.0 * (p[1] - p[0].powi(2)).powi(2);
231 let b = (1.0 - p[2]).powi(2) + 100.0 * (p[3] - p[2].powi(2)).powi(2);
232 a + b
233 });
234 match solver.optimize(&f) {
235 Ok(state) => {
236 let bp = solver.best_point;
237 println!("Nelder-Mead simplex (Rosenbrock 4D, {iterations} iters):");
238 println!(
239 " x = [{:.6}, {:.6}, {:.6}, {:.6}]",
240 bp[0], bp[1], bp[2], bp[3]
241 );
242 println!(" f(x) = {:.10e}", state.objective_value);
243 println!(" Converged: {}", state.converged);
244 }
245 Err(e) => eprintln!("Simplex failed: {e:?}"),
246 }
247}
248
249pub fn run_root(initial: f64, lower: f64, upper: f64, tolerance: f64) {
251 let cfg = SolverConfig {
253 max_iterations: 200,
254 tolerance,
255 step_size: 0.01,
256 verbose: false,
257 };
258 let mut solver = BoundedNewtonRaphson::new(initial, lower, upper, cfg);
259 let f = RootClosureFn(|x: f64| x * x * x - x - 1.0, |x: f64| 3.0 * x * x - 1.0);
260 match solver.find_root(&f) {
261 Ok(state) => {
262 let root = solver.get_root();
263 println!("Newton-Raphson root of f(x) = x³ − x − 1:");
264 println!(" root ≈ {root:.10e}");
265 println!(" f(root) = {:.4e}", x_cubed_minus_x_minus_one(root));
266 println!(
267 " Converged: {} ({} iters)",
268 state.converged, state.iteration
269 );
270 }
271 Err(e) => eprintln!("Root finder failed: {e:?}"),
272 }
273}
274
275fn x_cubed_minus_x_minus_one(x: f64) -> f64 {
276 x * x * x - x - 1.0
277}
278
279pub fn run_curve_fit(params_str: &str, x_str: &str, y_str: &str) {
281 let Some(p0) = parse_params4(params_str) else {
282 return;
283 };
284 let xs = parse_f64s(x_str);
285 let ys = parse_f64s(y_str);
286 if xs.is_empty() || ys.is_empty() || xs.len() != ys.len() {
287 eprintln!("x-data and y-data must be equal-length, non-empty comma-separated lists.");
288 return;
289 }
290
291 let mut xd = [0.0f64; 10];
293 let mut yd = [0.0f64; 10];
294 let n = xs.len().min(10);
295 xd[..n].copy_from_slice(&xs[..n]);
296 yd[..n].copy_from_slice(&ys[..n]);
297
298 let cfg = default_config(200, 1e-8);
299 let mut lm = LevenbergMarquardtStack::new(p0, cfg);
300 let model = CurveFn;
301 match lm.fit_curve(&model, &xd, &yd) {
302 Ok(state) => {
303 let p = lm.parameters;
304 println!("Levenberg-Marquardt curve fit (cubic: p0·x³+p1·x²+p2·x+p3):");
305 println!(
306 " params = [{:.6}, {:.6}, {:.6}, {:.6}]",
307 p[0], p[1], p[2], p[3]
308 );
309 println!(" χ² = {:.6e}", state.chi_squared);
310 println!(
311 " Converged: {} ({} iters)",
312 state.converged, state.iteration
313 );
314 }
315 Err(e) => eprintln!("Curve fit failed: {e:?}"),
316 }
317}
318
319pub fn run_ode_rk4(lambda: f64, t_start: f64, t_end: f64, y0: f64, step_size: f64) {
323 use qualia_core_db::modalities::calculus::ode_solver::{ExponentialDecay, Rk4Solver};
324 let system = ExponentialDecay::new(lambda);
325 let mut solver = Rk4Solver::new(system, step_size);
326 let result = solver.solve(t_start, t_end, y0);
327 println!("RK4 ODE (exponential decay λ={lambda}):");
328 println!(" t ∈ [{t_start}, {t_end}], y(0)={y0}, h={step_size}");
329 println!(" y(t_end) ≈ {result:.10e}");
330 println!(
331 " exact = {:.10e}",
332 y0 * (-lambda * (t_end - t_start)).exp()
333 );
334}
335
336pub fn run_ode_harmonic(omega: f64, t_start: f64, t_end: f64, y0: f64, step_size: f64) {
338 use qualia_core_db::modalities::calculus::ode_solver::{HarmonicOscillator, Rk4Solver};
339 let system = HarmonicOscillator::new(omega);
340 let mut solver = Rk4Solver::new(system, step_size);
341 let result = solver.solve(t_start, t_end, y0);
342 println!("RK4 ODE (harmonic oscillator ω={omega}):");
343 println!(" t ∈ [{t_start}, {t_end}], y(0)={y0}, h={step_size}");
344 println!(" y(t_end) ≈ {result:.10e}");
345}
346
347pub fn run_ode_bvp(t_start: f64, t_end: f64, y_left: f64, y_right: f64, threshold: f64) {
349 use qualia_core_db::modalities::calculus::ode_solver::{BvpSystem, ShootingMethod};
350
351 struct SimpleBvp {
352 lambda: f64,
353 }
354 impl BvpSystem for SimpleBvp {
355 fn derivative(&self, _t: f64, y: f64) -> f64 {
356 -self.lambda * y
357 }
358 fn boundary_left(&self, _a: f64) -> f64 {
359 0.0
360 }
361 fn boundary_right(&self, _b: f64) -> f64 {
362 0.0
363 }
364 }
365
366 let system = SimpleBvp { lambda: 1.0 };
367 let mut solver = ShootingMethod::new(system, threshold).with_max_iterations(500);
368 match solver.solve(t_start, t_end, y_left, y_right) {
369 Ok((ic, residual)) => {
370 println!("BVP shooting method (f'=-y):");
371 println!(" t ∈ [{t_start}, {t_end}]");
372 println!(" Converged IC : {ic:.8e}");
373 println!(" Residual : {residual:.4e}");
374 }
375 Err(e) => eprintln!("BVP failed to converge: {e}"),
376 }
377}
378
379pub fn run_ode_quantum_spectrum(planck_mass: f64, coupling: f64, max_n: u64, frequency: f64) {
381 use qualia_core_db::modalities::calculus::ode_solver::QuantizationMapper;
382 let qh = QuantizationMapper::new(planck_mass, coupling);
383 let spectrum = qh.compute_mass_spectrum(max_n, frequency);
384 println!("Quantum harmonic mass spectrum (M_p={planck_mass:.3e}, g={coupling:.3e}, f={frequency:.3e}):");
385 for (n, mass) in spectrum.iter().take(10) {
386 println!(" n={n:3} mass = {mass:.10e}");
387 }
388 if spectrum.len() > 10 {
389 println!(" … ({} total levels)", spectrum.len());
390 }
391}
392
393struct DemoQaoa(u8);
396
397impl QuantumCostFunction for DemoQaoa {
398 fn evaluate_quantum(&self, angles: &QAOAAngles) -> qualia_core_db::solvers::SolverResult<f64> {
399 let cost: f64 = angles.beta[..self.0 as usize]
401 .iter()
402 .map(|x| x * x)
403 .sum::<f64>()
404 + angles.gamma[..self.0 as usize]
405 .iter()
406 .map(|x| x * x)
407 .sum::<f64>();
408 Ok(cost)
409 }
410 fn evaluate_perturbed(
411 &self,
412 angles: &QAOAAngles,
413 perturbation: &QAOAAngles,
414 ) -> qualia_core_db::solvers::SolverResult<(f64, f64)> {
415 let mut plus = *angles;
416 let mut minus = *angles;
417 for i in 0..self.0 as usize {
418 plus.beta[i] += perturbation.beta[i];
419 minus.beta[i] -= perturbation.beta[i];
420 }
421 Ok((
422 self.evaluate_quantum(&plus)?,
423 self.evaluate_quantum(&minus)?,
424 ))
425 }
426 fn problem_size(&self) -> u8 {
427 self.0
428 }
429}
430
431pub fn run_quantum_qaoa(depth: u8, beta_str: &str, gamma_str: &str) {
433 let cfg = default_config(100, 1e-6);
434 let mut opt = QAOAAngleOptimizer::new(depth, cfg);
435 let betas = parse_f64s(beta_str);
436 let gammas = parse_f64s(gamma_str);
437 let mut init = QAOAAngles {
438 beta: [0.0; 10],
439 gamma: [0.0; 10],
440 };
441 for (i, &b) in betas.iter().take(10).enumerate() {
442 init.beta[i] = b;
443 }
444 for (i, &g) in gammas.iter().take(10).enumerate() {
445 init.gamma[i] = g;
446 }
447 let cost_fn = DemoQaoa(depth.min(10));
448 match opt.optimize(&cost_fn, init) {
449 Ok(state) => {
450 let final_a = opt.get_angles();
451 println!("QAOA angle optimizer (depth={depth}, demo MaxCut cost):");
452 println!(" Iterations : {}", state.iteration);
453 println!(" Quantum calls: {}", state.quantum_calls);
454 println!(" Final cost : {:.8e}", state.cost_value);
455 println!(" Converged : {}", state.converged);
456 println!(" β[0..d] = {:?}", &final_a.beta[..depth as usize]);
457 println!(" γ[0..d] = {:?}", &final_a.gamma[..depth as usize]);
458 }
459 Err(e) => eprintln!("QAOA optimization failed: {e:?}"),
460 }
461}
462
463struct DemoSpsa(#[allow(dead_code)] u8);
464
465impl SpsaCostFunction for DemoSpsa {
466 fn evaluate(&self, params: &[f64; 20], n: u8) -> qualia_core_db::solvers::SolverResult<f64> {
467 Ok(params[..n as usize].iter().map(|x| x * x).sum())
468 }
469 fn valid_parameters(&self, _p: &[f64; 20], _n: u8) -> bool {
470 true
471 }
472}
473
474pub fn run_quantum_spsa(num_params: u8, initial_str: &str) {
476 let vals = parse_f64s(initial_str);
477 let mut params = [0.0f64; 20];
478 let n = (num_params as usize).min(20).min(vals.len());
479 params[..n].copy_from_slice(&vals[..n]);
480 let cfg = default_config(200, 1e-6);
481 let mut opt = SpsaOptimizer::new(num_params, cfg);
482 let cost_fn = DemoSpsa(num_params);
483 match opt.optimize(&cost_fn, ¶ms) {
484 Ok(state) => {
485 let p = opt.get_parameters();
486 println!("SPSA optimizer (demo quadratic cost, {num_params} params):");
487 println!(" Iterations: {}", state.iteration);
488 println!(" Final cost: {:.8e}", state.cost_value);
489 println!(" Converged : {}", state.converged);
490 println!(" Params : {:?}", &p[..n]);
491 }
492 Err(e) => eprintln!("SPSA optimization failed: {e:?}"),
493 }
494}
495
496fn parse_u8s(s: &str) -> Vec<u8> {
499 s.split(',')
500 .filter_map(|t| t.trim().parse::<u8>().ok())
501 .collect()
502}
503
504pub fn run_symbolic_defeasible(facts_str: &str, rules_str: &str) {
506 let cfg = default_config(500, 1e-6);
507 let mut solver = ForwardChainingDefeasible::new(cfg);
508
509 for (idx, var) in parse_u8s(facts_str).into_iter().enumerate() {
511 let fact = Fact {
512 id: (idx as u32) + 1,
513 literal: Literal {
514 variable: var,
515 negated: false,
516 },
517 supporting_rules: [0; 3],
518 defeated: false,
519 confidence: 1.0,
520 };
521 if let Err(e) = solver.add_fact(fact) {
522 eprintln!(" Fact capacity exceeded: {e:?}");
523 break;
524 }
525 }
526
527 for (rid, rule_str) in rules_str.split(';').enumerate() {
529 let parts: Vec<&str> = rule_str.splitn(2, ':').collect();
530 if parts.len() != 2 {
531 continue;
532 }
533 let ants: Vec<u8> = parse_u8s(parts[0]);
534 let cons = parts[1].trim().parse::<u8>().unwrap_or(0);
535 let mut antecedents = [Literal {
536 variable: 0,
537 negated: false,
538 }; 5];
539 for (i, &a) in ants.iter().take(5).enumerate() {
540 antecedents[i] = Literal {
541 variable: a,
542 negated: false,
543 };
544 }
545 let rule = DefeasibleRule {
546 id: (rid as u32) + 1,
547 rule_type: RuleType::Defeasible,
548 antecedents,
549 consequent: Literal {
550 variable: cons,
551 negated: false,
552 },
553 priority: 500,
554 active: true,
555 fire_count: 0,
556 };
557 if let Err(e) = solver.add_rule(rule) {
558 eprintln!(" Rule capacity exceeded: {e:?}");
559 break;
560 }
561 }
562
563 match solver.infer() {
564 Ok(state) => {
565 println!("Defeasible logic inference:");
566 println!(" Facts at start : {}", parse_u8s(facts_str).len());
567 println!(" Facts after : {}", state.num_facts);
568 println!(" Rules fired : {}", state.rules_fired);
569 println!(" Iterations : {}", state.iteration);
570 println!(" Converged : {}", state.converged);
571 let active: Vec<u8> = solver
572 .get_facts()
573 .iter()
574 .filter(|f| f.id != 0 && !f.defeated)
575 .map(|f| f.literal.variable)
576 .collect();
577 println!(" Active literals: {active:?}");
578 }
579 Err(e) => eprintln!("Defeasible inference failed: {e:?}"),
580 }
581}
582
583pub fn run_symbolic_sat(clauses_str: &str) {
585 let cfg = default_config(1000, 1e-8);
586 let mut solver = BoundedSatSolver::new(cfg);
587
588 for (cid, clause_str) in clauses_str.split('|').enumerate() {
590 let lits: Vec<Literal> = clause_str
591 .split(',')
592 .filter_map(|tok| {
593 let tok = tok.trim();
594 let (neg, var_str) = if tok.starts_with('-') {
595 (true, &tok[1..])
596 } else {
597 (false, tok)
598 };
599 var_str.parse::<u8>().ok().map(|v| Literal {
600 variable: v,
601 negated: neg,
602 })
603 })
604 .collect();
605 let mut literals = [Literal {
606 variable: 0,
607 negated: false,
608 }; 5];
609 let n = lits.len().min(5) as u8;
610 for (i, l) in lits.iter().take(5).enumerate() {
611 literals[i] = *l;
612 }
613 let clause = Clause {
614 id: (cid as u32) + 1,
615 literals,
616 num_literals: n,
617 learned: false,
618 activity: 1.0,
619 };
620 if let Err(e) = solver.add_clause(clause) {
621 eprintln!(" Clause capacity exceeded: {e:?}");
622 break;
623 }
624 }
625
626 match solver.solve() {
627 Ok(state) => {
628 use qualia_core_db::solvers::symbolic_logic::AssignmentValue;
629 println!("SAT solver (DPLL):");
630 println!(" Iterations : {}", state.iteration);
631 println!(" Decisions : {}", state.num_decisions);
632 println!(
633 " Satisfiable : {}",
634 match state.satisfiable {
635 Some(true) => "yes",
636 Some(false) => "no",
637 None => "unknown",
638 }
639 );
640 let assignments = solver.get_assignments();
641 let assigned: Vec<_> = assignments
642 .iter()
643 .filter(|a| a.level != 0 || a.antecedent.is_some())
644 .map(|a| {
645 let v = match a.value {
646 AssignmentValue::True => "T",
647 AssignmentValue::False => "F",
648 AssignmentValue::Unassigned => "?",
649 };
650 format!("x[{}]={}", a.level, v)
651 })
652 .take(10)
653 .collect();
654 if !assigned.is_empty() {
655 println!(" Assignments : {}", assigned.join(", "));
656 }
657 }
658 Err(e) => eprintln!("SAT solve failed: {e:?}"),
659 }
660}