Skip to main content

qualia_core_db/research/
intentionality.rs

1//! Intentionality assessment — assess intent, classify mistakes.
2
3/// Intentionality classification.
4#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5pub enum Intentionality {
6    Intentional,
7    Negligent,
8    Reckless,
9    Accidental,
10    Unknowing,
11}
12
13impl Intentionality {
14    /// Stable string form.
15    pub fn as_str(&self) -> &'static str {
16        match self {
17            Self::Intentional => "intentional",
18            Self::Negligent => "negligent",
19            Self::Reckless => "reckless",
20            Self::Accidental => "accidental",
21            Self::Unknowing => "unknowing",
22        }
23    }
24}
25
26/// Mistake classification.
27#[derive(Debug, Clone, Copy, PartialEq, Eq)]
28pub enum MistakeType {
29    Honest,
30    Systematic,
31    Repeated,
32    Negligent,
33    Willful,
34}
35
36impl MistakeType {
37    /// Stable string form.
38    pub fn as_str(&self) -> &'static str {
39        match self {
40            Self::Honest => "honest",
41            Self::Systematic => "systematic",
42            Self::Repeated => "repeated",
43            Self::Negligent => "negligent",
44            Self::Willful => "willful",
45        }
46    }
47}
48
49/// Assess intentionality from evidence markers.
50///
51/// Takes evidence markers: `knew_outcome` (bool), `could_prevent` (bool),
52/// `repeated_behavior` (bool), `benefited` (bool), `acknowledged` (bool).
53pub fn assess_intentionality(
54    knew_outcome: bool,
55    could_prevent: bool,
56    repeated_behavior: bool,
57    benefited: bool,
58) -> Intentionality {
59    if knew_outcome && could_prevent && benefited {
60        Intentionality::Intentional
61    } else if knew_outcome && !could_prevent && repeated_behavior {
62        Intentionality::Reckless
63    } else if !knew_outcome && could_prevent && repeated_behavior {
64        Intentionality::Negligent
65    } else if !knew_outcome && !could_prevent {
66        Intentionality::Unknowing
67    } else {
68        Intentionality::Accidental
69    }
70}
71
72/// Classify a mistake based on pattern markers.
73///
74/// Takes: `first_occurrence` (bool), `pattern_matches` (count),
75/// `corrected_after_feedback` (bool), `systemic_factor` (bool).
76pub fn classify_mistake(
77    first_occurrence: bool,
78    pattern_matches: usize,
79    corrected_after_feedback: bool,
80    systemic_factor: bool,
81) -> MistakeType {
82    if first_occurrence && corrected_after_feedback {
83        MistakeType::Honest
84    } else if systemic_factor {
85        MistakeType::Systematic
86    } else if pattern_matches > 2 && !corrected_after_feedback {
87        MistakeType::Willful
88    } else if pattern_matches > 1 {
89        MistakeType::Repeated
90    } else {
91        MistakeType::Negligent
92    }
93}
94
95#[cfg(test)]
96mod tests {
97    use super::*;
98
99    #[test]
100    fn intentional_assessment() {
101        let i = assess_intentionality(true, true, true, true);
102        assert_eq!(i, Intentionality::Intentional);
103    }
104
105    #[test]
106    fn reckless_assessment() {
107        let i = assess_intentionality(true, false, true, false);
108        assert_eq!(i, Intentionality::Reckless);
109    }
110
111    #[test]
112    fn negligent_assessment() {
113        let i = assess_intentionality(false, true, true, false);
114        assert_eq!(i, Intentionality::Negligent);
115    }
116
117    #[test]
118    fn unknowing_assessment() {
119        let i = assess_intentionality(false, false, false, false);
120        assert_eq!(i, Intentionality::Unknowing);
121    }
122
123    #[test]
124    fn accidental_assessment() {
125        let i = assess_intentionality(true, true, false, false);
126        assert_eq!(i, Intentionality::Accidental);
127    }
128
129    #[test]
130    fn classify_honest_mistake() {
131        let m = classify_mistake(true, 0, true, false);
132        assert_eq!(m, MistakeType::Honest);
133    }
134
135    #[test]
136    fn classify_systematic_mistake() {
137        let m = classify_mistake(false, 1, true, true);
138        assert_eq!(m, MistakeType::Systematic);
139    }
140
141    #[test]
142    fn classify_willful_mistake() {
143        let m = classify_mistake(false, 5, false, false);
144        assert_eq!(m, MistakeType::Willful);
145    }
146
147    #[test]
148    fn classify_repeated_mistake() {
149        let m = classify_mistake(false, 3, true, false);
150        assert_eq!(m, MistakeType::Repeated);
151    }
152}