Skip to main content

logicaffeine_language/semantics/
axioms.rs

1//! Axiom expansion for predicates using lexical semantics.
2//!
3//! This module enriches logical expressions by:
4//!
5//! - **Hypernym inference**: "Dog(x)" → "Dog(x) ∧ Animal(x)"
6//! - **Verb entailments**: "Kill(e,x,y)" → "Kill(e,x,y) ∧ Cause(e,x,Dead(y))"
7//! - **Privative adjectives**: "Fake gun" → "FakeGun(x) ∧ ¬Gun(x)"
8//!
9//! The transformations use lexicon data generated at compile time.
10
11use crate::ast::{LogicExpr, NeoEventData, Term, ThematicRole};
12use crate::lexicon::{lookup_canonical, Polarity};
13use crate::token::TokenType;
14use logicaffeine_base::Arena;
15use logicaffeine_base::{Interner, Symbol};
16
17use super::{
18    is_privative_adjective, lookup_noun_entailments, lookup_noun_hypernyms, lookup_verb_entailment,
19};
20
21/// Apply axiom expansion to a logical expression.
22pub fn apply_axioms<'a>(
23    expr: &'a LogicExpr<'a>,
24    expr_arena: &'a Arena<LogicExpr<'a>>,
25    term_arena: &'a Arena<Term<'a>>,
26    interner: &mut Interner,
27) -> &'a LogicExpr<'a> {
28    transform_expr(expr, expr_arena, term_arena, interner)
29}
30
31fn transform_expr<'a>(
32    expr: &'a LogicExpr<'a>,
33    expr_arena: &'a Arena<LogicExpr<'a>>,
34    term_arena: &'a Arena<Term<'a>>,
35    interner: &mut Interner,
36) -> &'a LogicExpr<'a> {
37    match expr {
38        LogicExpr::Predicate { name, args, .. } => {
39            expand_predicate(*name, args, expr_arena, term_arena, interner)
40        }
41
42        LogicExpr::Quantifier {
43            kind,
44            variable,
45            body,
46            island_id,
47        } => {
48            let new_body = transform_expr(body, expr_arena, term_arena, interner);
49            expr_arena.alloc(LogicExpr::Quantifier {
50                kind: *kind,
51                variable: *variable,
52                body: new_body,
53                island_id: *island_id,
54            })
55        }
56
57        LogicExpr::BinaryOp { left, op, right } => {
58            let new_left = transform_expr(left, expr_arena, term_arena, interner);
59            let new_right = transform_expr(right, expr_arena, term_arena, interner);
60            expr_arena.alloc(LogicExpr::BinaryOp {
61                left: new_left,
62                op: op.clone(),
63                right: new_right,
64            })
65        }
66
67        LogicExpr::UnaryOp { op, operand } => {
68            let new_operand = transform_expr(operand, expr_arena, term_arena, interner);
69            expr_arena.alloc(LogicExpr::UnaryOp {
70                op: op.clone(),
71                operand: new_operand,
72            })
73        }
74
75        LogicExpr::NeoEvent(data) => expand_neo_event(data, expr_arena, term_arena, interner),
76
77        LogicExpr::Modal { vector, operand } => {
78            let new_operand = transform_expr(operand, expr_arena, term_arena, interner);
79            expr_arena.alloc(LogicExpr::Modal {
80                vector: *vector,
81                operand: new_operand,
82            })
83        }
84
85        LogicExpr::Temporal { operator, body } => {
86            let new_body = transform_expr(body, expr_arena, term_arena, interner);
87            expr_arena.alloc(LogicExpr::Temporal {
88                operator: *operator,
89                body: new_body,
90            })
91        }
92
93        LogicExpr::Lambda { variable, body } => {
94            let new_body = transform_expr(body, expr_arena, term_arena, interner);
95            expr_arena.alloc(LogicExpr::Lambda {
96                variable: *variable,
97                body: new_body,
98            })
99        }
100
101        LogicExpr::Question { wh_variable, body } => {
102            let new_body = transform_expr(body, expr_arena, term_arena, interner);
103            expr_arena.alloc(LogicExpr::Question {
104                wh_variable: *wh_variable,
105                body: new_body,
106            })
107        }
108
109        LogicExpr::YesNoQuestion { body } => {
110            let new_body = transform_expr(body, expr_arena, term_arena, interner);
111            expr_arena.alloc(LogicExpr::YesNoQuestion { body: new_body })
112        }
113
114        _ => expr,
115    }
116}
117
118fn expand_predicate<'a>(
119    name: Symbol,
120    args: &'a [Term<'a>],
121    expr_arena: &'a Arena<LogicExpr<'a>>,
122    term_arena: &'a Arena<Term<'a>>,
123    interner: &mut Interner,
124) -> &'a LogicExpr<'a> {
125    // A plural noun names the same predicate as its singular: "All dogs bark" and "Every dog
126    // barks" restrict to one `Dog`, as the prover's normalization reads them (`proof_convert`,
127    // `get_canonical_noun`). Only a lexicon-known plural changes; any other name is kept.
128    let name = match (
129        args.len(),
130        crate::lexicon::analyze_word(&interner.resolve(name).to_lowercase()),
131    ) {
132        (1, Some(crate::lexicon::WordAnalysis::Noun(meta)))
133            if meta.number == crate::lexicon::Number::Plural =>
134        {
135            let mut lemma = meta.lemma.to_string();
136            if let Some(first) = lemma.get_mut(..1) {
137                first.make_ascii_uppercase();
138            }
139            interner.intern(&lemma)
140        }
141        _ => name,
142    };
143    let name_str = interner.resolve(name).to_string();
144    let lower_name = name_str.to_lowercase();
145
146    // Check for canonical mapping (synonyms/antonyms)
147    // E.g., Lack(x,y) -> ¬Have(x,y), Possess(x,y) -> Have(x,y)
148    if let Some(mapping) = lookup_canonical(&lower_name) {
149        let canonical_sym = interner.intern(mapping.lemma);
150        let canonical_pred = expr_arena.alloc(LogicExpr::Predicate {
151            name: canonical_sym,
152            args,
153            world: None,
154        });
155
156        // Wrap antonyms in negation
157        return match mapping.polarity {
158            Polarity::Positive => canonical_pred,
159            Polarity::Negative => expr_arena.alloc(LogicExpr::UnaryOp {
160                op: TokenType::Not,
161                operand: canonical_pred,
162            }),
163        };
164    }
165
166    // Check for compound predicates (e.g., Fake-Gun from non-intersective adjectives)
167    if let Some(hyphen_pos) = name_str.find('-') {
168        let adj_part = name_str[..hyphen_pos].to_string();
169        let noun_part = name_str[hyphen_pos + 1..].to_string();
170
171        if is_privative_adjective(&adj_part) {
172            return expand_privative(&noun_part, args, expr_arena, term_arena, interner);
173        }
174    }
175
176    // Check for noun entailments (Bachelor -> Unmarried + Male)
177    let entailments = lookup_noun_entailments(&lower_name);
178    if !entailments.is_empty() {
179        return expand_noun_entailments(name, args, entailments, expr_arena, interner);
180    }
181
182    // Check for hypernyms (Dog -> Animal)
183    let hypernyms = lookup_noun_hypernyms(&lower_name);
184    if !hypernyms.is_empty() {
185        return expand_hypernyms(name, args, hypernyms, expr_arena, interner);
186    }
187
188    // No expansion needed - return original
189    expr_arena.alloc(LogicExpr::Predicate {
190        name,
191        args,
192        world: None,
193    })
194}
195
196fn expand_privative<'a>(
197    noun: &str,
198    args: &'a [Term<'a>],
199    expr_arena: &'a Arena<LogicExpr<'a>>,
200    term_arena: &'a Arena<Term<'a>>,
201    interner: &mut Interner,
202) -> &'a LogicExpr<'a> {
203    // Fake-Gun(x) => ¬Gun(x) ∧ Resembles(x, ^Gun)
204    let noun_sym = interner.intern(noun);
205    let resembles_sym = interner.intern("Resembles");
206
207    // Gun(x)
208    let noun_pred = expr_arena.alloc(LogicExpr::Predicate {
209        name: noun_sym,
210        args,
211        world: None,
212    });
213
214    // ¬Gun(x)
215    let negated_noun = expr_arena.alloc(LogicExpr::UnaryOp {
216        op: TokenType::Not,
217        operand: noun_pred,
218    });
219
220    // Resembles(x, ^Gun)
221    let intension_term = Term::Intension(noun_sym);
222    let mut resembles_args_vec = Vec::with_capacity(args.len() + 1);
223    if !args.is_empty() {
224        resembles_args_vec.push(clone_term(&args[0], term_arena));
225    }
226    resembles_args_vec.push(intension_term);
227    let resembles_args = term_arena.alloc_slice(resembles_args_vec);
228
229    let resembles_pred = expr_arena.alloc(LogicExpr::Predicate {
230        name: resembles_sym,
231        args: resembles_args,
232        world: None,
233    });
234
235    // ¬Gun(x) ∧ Resembles(x, ^Gun)
236    expr_arena.alloc(LogicExpr::BinaryOp {
237        left: negated_noun,
238        op: TokenType::And,
239        right: resembles_pred,
240    })
241}
242
243fn expand_noun_entailments<'a>(
244    base: Symbol,
245    args: &'a [Term<'a>],
246    entailments: &[&str],
247    expr_arena: &'a Arena<LogicExpr<'a>>,
248    interner: &mut Interner,
249) -> &'a LogicExpr<'a> {
250    // Bachelor(x) => Bachelor(x) ∧ Unmarried(x) ∧ Male(x)
251    let base_pred = expr_arena.alloc(LogicExpr::Predicate {
252        name: base,
253        args,
254        world: None,
255    });
256
257    let mut result: &LogicExpr = base_pred;
258    for entailment in entailments {
259        let ent_sym = interner.intern(entailment);
260        let ent_pred = expr_arena.alloc(LogicExpr::Predicate {
261            name: ent_sym,
262            args,
263            world: None,
264        });
265        result = expr_arena.alloc(LogicExpr::BinaryOp {
266            left: result,
267            op: TokenType::And,
268            right: ent_pred,
269        });
270    }
271
272    result
273}
274
275fn expand_hypernyms<'a>(
276    base: Symbol,
277    args: &'a [Term<'a>],
278    hypernyms: &[&str],
279    expr_arena: &'a Arena<LogicExpr<'a>>,
280    interner: &mut Interner,
281) -> &'a LogicExpr<'a> {
282    // Dog(x) => Dog(x) ∧ Animal(x)
283    let base_pred = expr_arena.alloc(LogicExpr::Predicate {
284        name: base,
285        args,
286        world: None,
287    });
288
289    let mut result: &LogicExpr = base_pred;
290    for hypernym in hypernyms {
291        let hyp_sym = interner.intern(hypernym);
292        let hyp_pred = expr_arena.alloc(LogicExpr::Predicate {
293            name: hyp_sym,
294            args,
295            world: None,
296        });
297        result = expr_arena.alloc(LogicExpr::BinaryOp {
298            left: result,
299            op: TokenType::And,
300            right: hyp_pred,
301        });
302    }
303
304    result
305}
306
307fn expand_neo_event<'a>(
308    data: &NeoEventData<'a>,
309    expr_arena: &'a Arena<LogicExpr<'a>>,
310    term_arena: &'a Arena<Term<'a>>,
311    interner: &mut Interner,
312) -> &'a LogicExpr<'a> {
313    let verb_str = interner.resolve(data.verb);
314    let lower_verb = verb_str.to_lowercase();
315
316    // Check for canonical mapping (synonyms/antonyms)
317    // E.g., Lack(x,y) -> ¬Have(x,y)
318    if let Some(mapping) = lookup_canonical(&lower_verb) {
319        let canonical_sym = interner.intern(mapping.lemma);
320
321        // Create NeoEvent with canonical verb
322        let canonical_event = expr_arena.alloc(LogicExpr::NeoEvent(Box::new(NeoEventData {
323            event_var: data.event_var,
324            verb: canonical_sym,
325            roles: data.roles,
326            modifiers: data.modifiers,
327            suppress_existential: data.suppress_existential,
328            world: None,
329        })));
330
331        // Wrap antonyms in negation
332        return match mapping.polarity {
333            Polarity::Positive => canonical_event,
334            Polarity::Negative => expr_arena.alloc(LogicExpr::UnaryOp {
335                op: TokenType::Not,
336                operand: canonical_event,
337            }),
338        };
339    }
340
341    if let Some((base_verb, manner_preds)) = lookup_verb_entailment(&lower_verb) {
342        // Murder(e) => Murder(e) ∧ Kill(e) ∧ Intentional(Agent)
343        let base_verb_sym = interner.intern(base_verb);
344
345        // Keep original NeoEvent
346        let original = expr_arena.alloc(LogicExpr::NeoEvent(Box::new(NeoEventData {
347            event_var: data.event_var,
348            verb: data.verb,
349            roles: data.roles,
350            modifiers: data.modifiers,
351            suppress_existential: data.suppress_existential,
352            world: None,
353        })));
354
355        // Create entailed verb NeoEvent (e.g., Kill)
356        let entailed_event = expr_arena.alloc(LogicExpr::NeoEvent(Box::new(NeoEventData {
357            event_var: data.event_var,
358            verb: base_verb_sym,
359            roles: data.roles,
360            modifiers: data.modifiers,
361            suppress_existential: data.suppress_existential,
362            world: None,
363        })));
364
365        // Conjoin original with entailed
366        let mut result = expr_arena.alloc(LogicExpr::BinaryOp {
367            left: original,
368            op: TokenType::And,
369            right: entailed_event,
370        });
371
372        // Add manner predicates (e.g., Intentional(Agent))
373        for manner in manner_preds {
374            let manner_sym = interner.intern(manner);
375
376            // Find the agent in roles
377            let agent_term = data
378                .roles
379                .iter()
380                .find(|(role, _)| *role == ThematicRole::Agent)
381                .map(|(_, term)| term);
382
383            if let Some(agent) = agent_term {
384                let manner_args = term_arena.alloc_slice([clone_term(agent, term_arena)]);
385                let manner_pred = expr_arena.alloc(LogicExpr::Predicate {
386                    name: manner_sym,
387                    args: manner_args,
388                    world: None,
389                });
390                result = expr_arena.alloc(LogicExpr::BinaryOp {
391                    left: result,
392                    op: TokenType::And,
393                    right: manner_pred,
394                });
395            }
396        }
397
398        result
399    } else {
400        // No entailment - return original unchanged
401        expr_arena.alloc(LogicExpr::NeoEvent(Box::new(NeoEventData {
402            event_var: data.event_var,
403            verb: data.verb,
404            roles: data.roles,
405            modifiers: data.modifiers,
406            suppress_existential: data.suppress_existential,
407            world: None,
408        })))
409    }
410}
411
412fn clone_term<'a>(term: &Term<'a>, arena: &'a Arena<Term<'a>>) -> Term<'a> {
413    match term {
414        Term::Constant(s) => Term::Constant(*s),
415        Term::Variable(s) => Term::Variable(*s),
416        Term::Function(s, args) => {
417            let cloned_args: Vec<Term<'a>> = args.iter().map(|t| clone_term(t, arena)).collect();
418            Term::Function(*s, arena.alloc_slice(cloned_args))
419        }
420        Term::Group(terms) => {
421            let cloned: Vec<Term<'a>> = terms.iter().map(|t| clone_term(t, arena)).collect();
422            Term::Group(arena.alloc_slice(cloned))
423        }
424        Term::Possessed {
425            possessor,
426            possessed,
427        } => {
428            let cloned_possessor = arena.alloc(clone_term(possessor, arena));
429            Term::Possessed {
430                possessor: cloned_possessor,
431                possessed: *possessed,
432            }
433        }
434        Term::Sigma(s) => Term::Sigma(*s),
435        Term::Intension(s) => Term::Intension(*s),
436        Term::Kind(s) => Term::Kind(*s),
437        Term::Proposition(e) => Term::Proposition(*e),
438        Term::Value {
439            kind,
440            unit,
441            dimension,
442        } => Term::Value {
443            kind: *kind,
444            unit: *unit,
445            dimension: *dimension,
446        },
447    }
448}