Skip to main content

qualia_cli/
solve.rs

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
17// ── Helpers ───────────────────────────────────────────────────────────────────
18
19fn 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
101// ── Linear algebra runners ────────────────────────────────────────────────────
102
103/// CLI: matrix multiply.
104pub 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
113/// CLI: determinant.
114pub 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
122/// CLI: linear system solve.
123pub 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
140/// CLI: eigenvalues.
141pub 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
158/// CLI: tensor contraction.
159pub 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            // Sum all elements as a scalar trace equivalent
169            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
189// ── ObjectiveFunction adapter for closures ────────────────────────────────────
190
191struct 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    // cubic model: p[0]*x³ + p[1]*x² + p[2]*x + p[3]
211    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
219// ── Optimization runners ──────────────────────────────────────────────────────
220
221/// CLI: simplex LP.
222pub 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    // Rosenbrock 4D: f(x,y,z,w) = (1-x)² + 100(y-x²)² + (1-z)² + 100(w-z²)²
229    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
249/// CLI: root finding.
250pub fn run_root(initial: f64, lower: f64, upper: f64, tolerance: f64) {
251    // f(x) = x³ − x − 1  (plastic constant, root ≈ 1.32472)
252    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
279/// CLI: curve fit.
280pub 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    // Pad/truncate to exactly 10 points (LM stack uses fixed 10-point buffer)
292    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
319// ── ODE runners ───────────────────────────────────────────────────────────────
320
321/// CLI: ODE RK4.
322pub 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
336/// CLI: ODE harmonic oscillator.
337pub 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
347/// CLI: .
348pub 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
379/// CLI: .
380pub 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
393// ── Quantum optimizer runners ─────────────────────────────────────────────────
394
395struct DemoQaoa(u8);
396
397impl QuantumCostFunction for DemoQaoa {
398    fn evaluate_quantum(&self, angles: &QAOAAngles) -> qualia_core_db::solvers::SolverResult<f64> {
399        // Demo MaxCut-like cost: minimize sum of angle squares
400        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
431/// CLI: .
432pub 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
474/// CLI: .
475pub 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, &params) {
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
496// ── Symbolic logic runners ────────────────────────────────────────────────────
497
498fn parse_u8s(s: &str) -> Vec<u8> {
499    s.split(',')
500        .filter_map(|t| t.trim().parse::<u8>().ok())
501        .collect()
502}
503
504/// CLI: .
505pub 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    // Parse facts: comma-separated variable indices (1-based)
510    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    // Parse rules: "ant1,ant2:cons" pairs separated by ';'
528    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
583/// CLI: .
584pub fn run_symbolic_sat(clauses_str: &str) {
585    let cfg = default_config(1000, 1e-8);
586    let mut solver = BoundedSatSolver::new(cfg);
587
588    // Parse clauses: "1,-2,3|4,-5" — pipe-separated clauses, comma-separated literals
589    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}