qualia_core_db/modalities/argumentation/
vaf.rs1use super::ArgumentationFramework;
8use std::collections::{HashMap, HashSet};
9
10#[derive(Debug, Clone)]
12pub struct ValueArgumentationFramework {
13 pub af: ArgumentationFramework,
14 pub value_of: HashMap<u64, u64>,
16 pub value_rank: HashMap<u64, u32>,
18}
19
20impl ValueArgumentationFramework {
21 pub fn new(af: ArgumentationFramework) -> Self {
23 Self {
24 af,
25 value_of: HashMap::new(),
26 value_rank: HashMap::new(),
27 }
28 }
29
30 pub fn set_value(&mut self, arg: u64, value: u64) {
32 self.value_of.insert(arg, value);
33 }
34
35 pub fn set_rank(&mut self, value: u64, rank: u32) {
37 self.value_rank.insert(value, rank);
38 }
39
40 fn rank_of_arg(&self, arg: u64) -> u32 {
41 self.value_of
42 .get(&arg)
43 .and_then(|v| self.value_rank.get(v))
44 .copied()
45 .unwrap_or(0)
46 }
47
48 pub fn defeats(&self, attacker: u64, target: u64) -> bool {
52 self.rank_of_arg(attacker) >= self.rank_of_arg(target)
53 }
54
55 pub fn defeat_framework(&self) -> ArgumentationFramework {
57 let mut out = ArgumentationFramework::new();
58 for arg in self.af.arguments.values() {
59 out.add_argument(arg.clone());
60 }
61 for atk in &self.af.attacks {
62 if self.defeats(atk.attacker, atk.target) {
63 out.add_attack(atk.clone());
64 }
65 }
66 out
67 }
68
69 pub fn grounded_extension(&self) -> HashSet<u64> {
71 self.defeat_framework().grounded_extension()
72 }
73
74 pub fn preferred_extensions(&self) -> Vec<HashSet<u64>> {
76 self.defeat_framework().preferred_extensions()
77 }
78}
79
80#[cfg(test)]
81mod tests {
82 use super::super::{Argument, Attack, AttackType};
83 use super::*;
84 use crate::NQuin;
85
86 fn arg(id: u64) -> Argument {
87 Argument::new(id, String::new(), Vec::new(), NQuin::default())
88 }
89 fn atk(a: u64, b: u64) -> Attack {
90 Attack {
91 attacker: a,
92 target: b,
93 attack_type: AttackType::Rebuttal,
94 strength: 1.0,
95 }
96 }
97
98 #[test]
99 fn higher_value_argument_survives_a_mutual_attack() {
100 let mut af = ArgumentationFramework::new();
102 af.add_argument(arg(1));
103 af.add_argument(arg(2));
104 af.add_attack(atk(1, 2));
105 af.add_attack(atk(2, 1));
106 assert!(
107 af.grounded_extension().is_empty(),
108 "plain AF: mutual attack → no acceptance"
109 );
110
111 let mut vaf = ValueArgumentationFramework::new(af);
113 let rights = crate::q_hash("value:nonDerogableRight");
114 let convenience = crate::q_hash("value:convenience");
115 vaf.set_value(1, rights);
116 vaf.set_value(2, convenience);
117 vaf.set_rank(rights, 10);
118 vaf.set_rank(convenience, 1);
119
120 assert!(vaf.defeats(1, 2));
122 assert!(!vaf.defeats(2, 1));
123 let g = vaf.grounded_extension();
124 assert!(
125 g.contains(&1) && !g.contains(&2),
126 "the rights-grounded argument prevails"
127 );
128 }
129}