Skip to main content

qualia_cli/
evaluate.rs

1use qualia_core_db::deontic_logic::{evaluate_accessible_layers, VcAttributes};
2use qualia_core_db::modalities::epistemic::{
3    evaluate_epistemic_frame, EpistemicStatus, EpistemicVerdict,
4};
5use qualia_core_db::modalities::paraconsistent::route_paraconsistent;
6use qualia_core_db::NQuin;
7use std::fs::File;
8use std::path::Path;
9
10/// Memory-maps the quin file.
11pub fn map_quins(path: &Path) -> std::io::Result<(memmap2::Mmap, usize)> {
12    let file = File::open(path)?;
13    let mmap = unsafe { memmap2::MmapOptions::new().map(&file)? };
14    let len = mmap.len();
15    Ok((mmap, len))
16}
17
18const EMPTY_QUIN: NQuin = NQuin {
19    subject: 0,
20    predicate: 0,
21    object: 0,
22    context: 0,
23    metadata: 0,
24    parity: 0,
25};
26
27/// Try to cast a memory-mapped file to a slice of NQuins.
28/// Prints a diagnostic and returns an empty slice on failure.
29fn cast_quins(mmap: &memmap2::Mmap) -> &[NQuin] {
30    match bytemuck::try_cast_slice(mmap.as_ref()) {
31        Ok(q) => q,
32        Err(e) => {
33            eprintln!("cast_slice failed ({e:?}) — file may have a volume header; try stripping with `qualia-cli inspect`");
34            &[]
35        }
36    }
37}
38
39// ── Existing modalities ───────────────────────────────────────────────────────
40
41/// CLI: deontic evaluation.
42pub fn run_deontic(dataset: &Path, contract_hash: u64) {
43    let (mmap, len) = match map_quins(dataset) {
44        Ok(r) => r,
45        Err(e) => {
46            eprintln!("Cannot open dataset: {e}");
47            return;
48        }
49    };
50    let quins = cast_quins(&mmap);
51    println!("Mapped {} quins ({len} bytes).", quins.len());
52
53    let vc = VcAttributes::from_quins(contract_hash, quins);
54    let storage_dir = std::env::var("QUALIA_DATA_DIR").unwrap_or_else(|_| ".".to_string());
55    let vault = match qualia_core_db::key_vault::KeyVault::load_or_generate(&storage_dir) {
56        Ok(v) => v,
57        Err(e) => {
58            eprintln!("KeyVault error: {e}");
59            return;
60        }
61    };
62    let mut out: [Option<(
63        qualia_core_db::key_vault::SubgraphLayer,
64        qualia_core_db::key_vault::SubgraphKey,
65    )>; 5] = [None, None, None, None, None];
66    let count = evaluate_accessible_layers(&vault, &vc, &[], &mut out);
67    println!("Deontic evaluation for contract 0x{contract_hash:016x}:");
68    if count == 0 {
69        println!("  No permitted layers found.");
70    }
71    for (layer, _key) in out.iter().take(count).flatten() {
72        println!("  Permitted layer: {layer:?}");
73    }
74}
75
76/// CLI: epistemic evaluation.
77pub fn run_epistemic(dataset: &Path, agent_hash: u64) {
78    let (mmap, len) = match map_quins(dataset) {
79        Ok(r) => r,
80        Err(e) => {
81            eprintln!("Cannot open dataset: {e}");
82            return;
83        }
84    };
85    let quins = cast_quins(&mmap);
86    println!("Mapped {} quins ({len} bytes).", quins.len());
87
88    let empty = EpistemicVerdict {
89        claim: EMPTY_QUIN,
90        status: EpistemicStatus::Uncertain,
91        certainty: 0,
92    };
93    let mut out = vec![empty; 128];
94    match evaluate_epistemic_frame(quins, agent_hash, 0, &mut out) {
95        Ok(n) => println!("Epistemic: {n} verdicts for agent 0x{agent_hash:016x}."),
96        Err(e) => eprintln!("Epistemic error: {e:?}"),
97    }
98}
99
100/// CLI: paraconsistent evaluation.
101pub fn run_paraconsistent(dataset: &Path) {
102    let (mmap, len) = match map_quins(dataset) {
103        Ok(r) => r,
104        Err(e) => {
105            eprintln!("Cannot open dataset: {e}");
106            return;
107        }
108    };
109    let quins = cast_quins(&mmap);
110    println!("Mapped {} quins ({len} bytes).", quins.len());
111
112    let mut out_ok = vec![EMPTY_QUIN; quins.len().max(1)];
113    let mut out_iso = vec![EMPTY_QUIN; quins.len().max(1)];
114    match route_paraconsistent(quins, &mut out_ok, &mut out_iso) {
115        Ok((ok, iso)) => {
116            println!("Paraconsistent routing:");
117            println!("  Consistent   : {ok}");
118            println!("  Isolated (⊥) : {iso}");
119        }
120        Err(e) => eprintln!("Paraconsistent error: {e:?}"),
121    }
122}
123
124// ── New modalities ────────────────────────────────────────────────────────────
125
126/// CLI: LTL evaluation.
127pub fn run_ltl(dataset: &Path, formula_type: &str, hash_a: u64, hash_b: u64) {
128    use qualia_core_db::modalities::temporal_ltl::{evaluate_ltl_trace, LtlFormula};
129
130    let formula = match formula_type.to_ascii_lowercase().as_str() {
131        "globally" | "g" => LtlFormula::Globally(hash_a),
132        "next" | "x" => LtlFormula::Next(hash_a),
133        "until" | "u" => LtlFormula::Until {
134            ante: hash_a,
135            consequent: hash_b,
136        },
137        other => {
138            eprintln!("Unknown LTL operator '{other}'. Use: globally, next, until");
139            return;
140        }
141    };
142
143    let (mmap, _) = match map_quins(dataset) {
144        Ok(r) => r,
145        Err(e) => {
146            eprintln!("Cannot open dataset: {e}");
147            return;
148        }
149    };
150    let trace = cast_quins(&mmap);
151
152    let result = evaluate_ltl_trace(trace, &formula);
153    println!(
154        "LTL trace evaluation ({formula_type} 0x{hash_a:x}): {}",
155        if result { "HOLDS" } else { "VIOLATED" }
156    );
157}
158
159/// CLI: ASP evaluation.
160pub fn run_asp(dataset: &Path, base_index: usize) {
161    use qualia_core_db::modalities::asp::{enumerate_stable_models, MAX_STABLE_MODELS};
162
163    let (mmap, _) = match map_quins(dataset) {
164        Ok(r) => r,
165        Err(e) => {
166            eprintln!("Cannot open dataset: {e}");
167            return;
168        }
169    };
170    let quins = cast_quins(&mmap);
171
172    if quins.is_empty() {
173        eprintln!("Empty dataset.");
174        return;
175    }
176    let base = quins.get(base_index).copied().unwrap_or(EMPTY_QUIN);
177    let mut out = [0u64; MAX_STABLE_MODELS];
178    let count = enumerate_stable_models(&base, quins, &mut out);
179    println!("ASP: {count} stable model(s) from base quin at index {base_index}:");
180    for h in &out[..count] {
181        println!("  0x{h:016x}");
182    }
183}
184
185/// CLI: description-logic evaluation.
186pub fn run_dl(dataset: &Path, sub_class: u64, super_class: u64) {
187    use qualia_core_db::modalities::dl::check_subsumption_quin;
188
189    let (mmap, _) = match map_quins(dataset) {
190        Ok(r) => r,
191        Err(e) => {
192            eprintln!("Cannot open dataset: {e}");
193            return;
194        }
195    };
196    let tbox = cast_quins(&mmap);
197
198    let result = check_subsumption_quin(sub_class, super_class, tbox);
199    println!(
200        "DL subsumption: 0x{sub_class:x} ⊑ 0x{super_class:x}  →  {}",
201        if result {
202            "TRUE (subclass confirmed)"
203        } else {
204            "FALSE (not subsumed)"
205        }
206    );
207}
208
209/// CLI: probabilistic evaluation.
210pub fn run_probabilistic(weight: f32, threshold: f32) {
211    use qualia_core_db::modalities::probabilistic::evaluate_threshold;
212    let result = evaluate_threshold(weight, threshold);
213    println!(
214        "Probabilistic: weight={weight:.4}, threshold={threshold:.4}  →  {}",
215        if result {
216            "ABOVE THRESHOLD"
217        } else {
218            "BELOW THRESHOLD"
219        }
220    );
221}
222
223/// CLI: linear-logic evaluation.
224pub fn run_linear_logic(dataset: &Path, quin_index: usize) {
225    use qualia_core_db::modalities::linear::{consume_quin, is_consumed};
226
227    let (mmap, _) = match map_quins(dataset) {
228        Ok(r) => r,
229        Err(e) => {
230            eprintln!("Cannot open dataset: {e}");
231            return;
232        }
233    };
234    let quins = cast_quins(&mmap);
235
236    match quins.get(quin_index) {
237        None => eprintln!(
238            "Quin index {quin_index} out of range (dataset has {} quins).",
239            quins.len()
240        ),
241        Some(q) => {
242            let consumed_before = is_consumed(q);
243            let mut mutable_q = *q;
244            consume_quin(&mut mutable_q);
245            println!("Linear logic consume on quin[{quin_index}]:");
246            println!(
247                "  Before consume: {}",
248                if consumed_before {
249                    "already consumed"
250                } else {
251                    "available"
252                }
253            );
254            println!(
255                "  After  consume: {}",
256                if is_consumed(&mutable_q) {
257                    "consumed"
258                } else {
259                    "still available (check bit encoding)"
260                }
261            );
262        }
263    }
264}
265
266/// CLI: dialectical evaluation.
267pub fn run_dialectical(dataset: &Path, var1: u64, var2: u64) {
268    use qualia_core_db::modalities::dialectical::{are_confounded, do_intervention};
269
270    let (mmap, _) = match map_quins(dataset) {
271        Ok(r) => r,
272        Err(e) => {
273            eprintln!("Cannot open dataset: {e}");
274            return;
275        }
276    };
277    let graph = cast_quins(&mmap);
278
279    let confounded = are_confounded(graph, var1, var2);
280    println!("Dialectical analysis:");
281    println!("  var1=0x{var1:x}, var2=0x{var2:x}");
282    println!("  Confounded: {confounded}");
283
284    if let Some(effect) = do_intervention(graph, var1, 1, var2) {
285        println!("  Intervention (set var1=1) → effect on var2: {effect:.4}");
286    } else {
287        println!("  Intervention: insufficient data for causal effect estimate.");
288    }
289}
290
291/// CLI: .
292pub fn run_diffusion(graph_id: &str) {
293    use qualia_core_db::modalities::diffusion::trigger_diffusion;
294    let triggered = trigger_diffusion(graph_id);
295    println!(
296        "Diffusion trigger for graph '{}': {}",
297        graph_id,
298        if triggered {
299            "initiated"
300        } else {
301            "already active or no-op"
302        }
303    );
304}
305
306/// CLI: .
307pub fn run_spatio_temporal(
308    action: &str,
309    ax1: f64,
310    ay1: f64,
311    ax2: f64,
312    ay2: f64,
313    bx1: f64,
314    by1: f64,
315    bx2: f64,
316    by2: f64,
317) {
318    use qualia_core_db::modalities::spatio_temporal::{
319        evaluate_rcc8, evaluate_temporal, SpatialRegion, TemporalOp,
320    };
321
322    match action.to_ascii_lowercase().as_str() {
323        "rcc8" => {
324            let region_a =
325                SpatialRegion::new(1, vec![(ax1, ay1), (ax2, ay1), (ax2, ay2), (ax1, ay2)]);
326            let region_b =
327                SpatialRegion::new(2, vec![(bx1, by1), (bx2, by1), (bx2, by2), (bx1, by2)]);
328            let relation = evaluate_rcc8(&region_a, &region_b);
329            println!("RCC8 relation A({ax1},{ay1})-({ax2},{ay2}) vs B({bx1},{by1})-({bx2},{by2}): {relation:?}");
330        }
331        "temporal-before" => {
332            let result = evaluate_temporal(
333                TemporalOp::Before,
334                ax1 as i64,
335                ay1 as i64,
336                bx1 as i64,
337                by1 as i64,
338            );
339            println!("Temporal BEFORE [{ax1}..{ay1}] vs [{bx1}..{by1}]: {result}");
340        }
341        "temporal-meets" => {
342            let result = evaluate_temporal(
343                TemporalOp::Meets,
344                ax1 as i64,
345                ay1 as i64,
346                bx1 as i64,
347                by1 as i64,
348            );
349            println!("Temporal MEETS [{ax1}..{ay1}] vs [{bx1}..{by1}]: {result}");
350        }
351        "temporal-overlaps" => {
352            let result = evaluate_temporal(
353                TemporalOp::Overlaps,
354                ax1 as i64,
355                ay1 as i64,
356                bx1 as i64,
357                by1 as i64,
358            );
359            println!("Temporal OVERLAPS [{ax1}..{ay1}] vs [{bx1}..{by1}]: {result}");
360        }
361        "temporal-during" => {
362            let result = evaluate_temporal(
363                TemporalOp::During,
364                ax1 as i64,
365                ay1 as i64,
366                bx1 as i64,
367                by1 as i64,
368            );
369            println!("Temporal DURING [{ax1}..{ay1}] vs [{bx1}..{by1}]: {result}");
370        }
371        other => {
372            eprintln!("Unknown spatio-temporal action '{other}'. Use: rcc8, temporal-before, temporal-meets, temporal-overlaps, temporal-during");
373        }
374    }
375}
376
377/// CLI: .
378pub fn run_interval(action: &str, start1: i64, end1: i64, start2: i64, end2: i64, point: i64) {
379    use qualia_core_db::modalities::interval_reasoning::TemporalInterval;
380
381    let a = TemporalInterval::new(1, start1, end1);
382    let b = TemporalInterval::new(2, start2, end2);
383
384    match action.to_ascii_lowercase().as_str() {
385        "contains" => println!(
386            "Interval [{start1}..{end1}].contains({point}): {}",
387            a.contains(point)
388        ),
389        "overlaps" => println!(
390            "Interval [{start1}..{end1}] overlaps [{start2}..{end2}]: {}",
391            a.overlaps(&b)
392        ),
393        "intersection" => match a.intersection(&b) {
394            Some(i) => println!("Intersection: [{}..{}]", i.start, i.end),
395            None => println!("Intervals do not intersect."),
396        },
397        "union" => {
398            let u = a.union(&b);
399            println!("Union: [{}..{}]", u.start, u.end);
400        }
401        "gap" => match a.gap(&b) {
402            Some(g) => println!("Gap between intervals: {g} time units"),
403            None => println!("Intervals overlap — no gap."),
404        },
405        other => {
406            eprintln!("Unknown interval action '{other}'. Use: contains, overlaps, intersection, union, gap");
407        }
408    }
409}
410
411/// CLI: .
412pub fn run_graph_topology(dataset: &Path, context: u64) {
413    use qualia_core_db::modalities::graph_theory::analyze_graph_topology;
414
415    let (mmap, _) = match map_quins(dataset) {
416        Ok(r) => r,
417        Err(e) => {
418            eprintln!("Cannot open dataset: {e}");
419            return;
420        }
421    };
422    let quins = cast_quins(&mmap);
423
424    let result = match analyze_graph_topology(quins, context) {
425        Ok(result) => result,
426        Err(err) => {
427            eprintln!("Graph topology analysis failed: {err:?}");
428            return;
429        }
430    };
431    println!("Graph topology analysis (context=0x{context:x}):");
432    println!("  Nodes        : {}", result.node_count);
433    println!("  Edges        : {}", result.edge_count);
434    println!("  Density      : {:.4}", result.density);
435    println!("  Communities  : {}", result.communities.len());
436    println!("  Motifs found : {}", result.motifs.len());
437    if !result.top_nodes.is_empty() {
438        println!("  Top nodes by centrality:");
439        for (node_id, score) in result.top_nodes.iter().take(5) {
440            println!("    0x{node_id:016x}  centrality={score:.4}");
441        }
442    }
443}
444
445/// CLI: .
446pub fn run_argumentation(demo: bool, dataset: Option<&Path>) {
447    use qualia_core_db::modalities::argumentation::{
448        create_sanctuary_debate, ArgumentationFramework,
449    };
450
451    let framework: ArgumentationFramework = if demo || dataset.is_none() {
452        create_sanctuary_debate()
453    } else {
454        // Build a minimal framework from the dataset's quins:
455        // each quin.subject attacks quin.object if predicate matches "attacks" hash
456        let (mmap, _) = match dataset.map(|p| map_quins(p)).unwrap() {
457            Ok(r) => r,
458            Err(e) => {
459                eprintln!("Cannot open dataset: {e}");
460                return;
461            }
462        };
463        let quins = cast_quins(&mmap);
464        let attack_pred = qualia_core_db::q_hash("attacks");
465        let mut fw = ArgumentationFramework::new();
466        for q in quins {
467            if q.predicate == attack_pred {
468                fw.add_attack(qualia_core_db::modalities::argumentation::Attack {
469                    attacker: q.subject,
470                    target: q.object,
471                    attack_type: qualia_core_db::modalities::argumentation::AttackType::Rebuttal,
472                    strength: 1.0,
473                });
474            }
475        }
476        fw
477    };
478
479    let grounded = framework.grounded_extension();
480    println!("Argumentation framework analysis:");
481    println!("  Arguments    : {}", framework.arguments.len());
482    println!("  Attacks      : {}", framework.attacks.len());
483    println!("  Grounded ext : {} argument(s)", grounded.len());
484    if grounded.is_empty() {
485        println!("  (empty grounded extension — all arguments attacked)");
486    }
487    for id in &grounded {
488        if let Some(arg) = framework.arguments.get(id) {
489            println!("    0x{id:016x}  \"{}\"", arg.content);
490        } else {
491            println!("    0x{id:016x}");
492        }
493    }
494}
495
496/// CLI: .
497pub fn run_control_feedback(kp: f64, ki: f64, kd: f64, setpoint: f64, measurement: f64) {
498    use qualia_core_db::modalities::control_feedback::{FeedbackController, PidParameters};
499
500    let params = PidParameters {
501        kp,
502        ki,
503        kd,
504        output_min: f64::NEG_INFINITY,
505        output_max: f64::INFINITY,
506    };
507    let mut ctrl = FeedbackController::new("cli".to_string(), setpoint, measurement, params);
508    let output = ctrl.compute_output();
509    println!("PID controller:");
510    println!("  Kp={kp}, Ki={ki}, Kd={kd}");
511    println!("  Setpoint={setpoint}, Measurement={measurement}");
512    println!("  Control output: {output:.6}");
513}
514
515/// CLI: .
516pub fn run_neuro_symbolic() {
517    use qualia_core_db::neuro_symbolic_sieve::SieveLexSpec;
518    use qualia_core_db::q_hash;
519
520    // Demonstrate the grammar sieve spec — shows which NQuin hashes constrain token generation
521    let spec = SieveLexSpec::fever_observation();
522
523    println!("Neuro-symbolic grammar sieve — fever observation demo");
524    println!("  The sieve constrains LLM token generation to well-typed NQuins.");
525    println!("  Token masks are built from the '.q42.lex' lexicon at runtime.");
526    println!();
527    println!("  State machine: ExpectSubject → ExpectPredicate → ExpectObject → Complete");
528    println!();
529    println!("  Allowed hashes:");
530    for i in 0..spec.subjects_len as usize {
531        println!(
532            "    Subject[{i}]   : 0x{:016x}  (q_hash(\"Patient\") = 0x{:016x})",
533            spec.subjects[i],
534            q_hash("Patient")
535        );
536    }
537    for i in 0..spec.predicates_len as usize {
538        println!(
539            "    Predicate[{i}] : 0x{:016x}  (q_hash(\"fever\") = 0x{:016x})",
540            spec.predicates[i],
541            q_hash("fever")
542        );
543    }
544    for i in 0..spec.objects_len as usize {
545        println!(
546            "    Object[{i}]    : 0x{:016x}  (q_hash(\"True\") = 0x{:016x})",
547            spec.objects[i],
548            q_hash("True")
549        );
550    }
551    println!();
552    // Full clinical spec
553    let full = SieveLexSpec::graph_mutation_default();
554    println!(
555        "  graph_mutation_default spec ({} subjects, {} predicates, {} objects):",
556        full.subjects_len, full.predicates_len, full.objects_len
557    );
558    for i in 0..full.subjects_len as usize {
559        println!("    Subject[{i}]   : 0x{:016x}", full.subjects[i]);
560    }
561    for i in 0..full.predicates_len as usize {
562        println!("    Predicate[{i}] : 0x{:016x}", full.predicates[i]);
563    }
564    for i in 0..full.objects_len as usize {
565        println!("    Object[{i}]    : 0x{:016x}", full.objects[i]);
566    }
567    println!();
568    println!("  At inference time, NeuroSymbolicSieve::from_lex_and_tokenizer() maps each");
569    println!("  hash to allowed token IDs from the GGUF vocabulary.  Any token not in the");
570    println!("  current mask has its logit set to -∞, enforcing SHACL-typed output.");
571}