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
10pub 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
27fn 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
39pub 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
76pub 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
100pub 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
124pub 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
159pub 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
185pub 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
209pub 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
223pub 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
266pub 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
291pub 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
306pub 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(®ion_a, ®ion_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
377pub 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
411pub 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
445pub 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 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
496pub 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
515pub fn run_neuro_symbolic() {
517 use qualia_core_db::neuro_symbolic_sieve::SieveLexSpec;
518 use qualia_core_db::q_hash;
519
520 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 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}