Skip to main content

qualia_core_db/modalities/argumentation/
vaf.rs

1//! Value-based Argumentation Frameworks (Bench-Capon) — attacks succeed only when the attacker's
2//! value is not less preferred than the target's. This lets a **human-rights hierarchy** decide
3//! conflicts: an attack from a less-important value cannot defeat an argument grounded in a
4//! more-important (e.g. non-derogable) right. The result projects to a standard Dung framework of
5//! successful *defeats*, over which the usual semantics apply.
6
7use super::ArgumentationFramework;
8use std::collections::{HashMap, HashSet};
9
10/// A Dung framework augmented with a value per argument and an audience preference over values.
11#[derive(Debug, Clone)]
12pub struct ValueArgumentationFramework {
13    pub af: ArgumentationFramework,
14    /// argument id → its value (e.g. a human-rights principle hash).
15    pub value_of: HashMap<u64, u64>,
16    /// value → audience preference rank (higher = more important / more preferred).
17    pub value_rank: HashMap<u64, u32>,
18}
19
20impl ValueArgumentationFramework {
21    /// Creates `ValueArgumentationFramework` with the given state.
22    pub fn new(af: ArgumentationFramework) -> Self {
23        Self {
24            af,
25            value_of: HashMap::new(),
26            value_rank: HashMap::new(),
27        }
28    }
29
30    /// Assign argument `arg` the value `value`.
31    pub fn set_value(&mut self, arg: u64, value: u64) {
32        self.value_of.insert(arg, value);
33    }
34
35    /// Set the audience preference `rank` for `value` (higher = more preferred).
36    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    /// An attack `attacker → target` **defeats** `target` iff
49    /// `rank(value(attacker)) >= rank(value(target))` — an attack from a less-preferred value
50    /// cannot defeat a more-preferred (e.g. non-derogable rights) argument.
51    pub fn defeats(&self, attacker: u64, target: u64) -> bool {
52        self.rank_of_arg(attacker) >= self.rank_of_arg(target)
53    }
54
55    /// Project to the Dung framework of successful **defeats** (attacks that pass the value test).
56    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    /// Grounded extension under the audience's value preference.
70    pub fn grounded_extension(&self) -> HashSet<u64> {
71        self.defeat_framework().grounded_extension()
72    }
73
74    /// Preferred extensions under the audience's value preference.
75    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        // a ↔ b mutually attack. In a plain AF, neither is grounded.
101        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        // Now value(1)=rights (rank 10), value(2)=convenience (rank 1).
112        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        // 1 defeats 2 (10 >= 1); 2 does NOT defeat 1 (1 < 10). So only 1→2 survives → grounded {1}.
121        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}