1use 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
21pub 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 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 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 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 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 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 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 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 let noun_sym = interner.intern(noun);
205 let resembles_sym = interner.intern("Resembles");
206
207 let noun_pred = expr_arena.alloc(LogicExpr::Predicate {
209 name: noun_sym,
210 args,
211 world: None,
212 });
213
214 let negated_noun = expr_arena.alloc(LogicExpr::UnaryOp {
216 op: TokenType::Not,
217 operand: noun_pred,
218 });
219
220 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 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 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 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 if let Some(mapping) = lookup_canonical(&lower_verb) {
319 let canonical_sym = interner.intern(mapping.lemma);
320
321 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 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 let base_verb_sym = interner.intern(base_verb);
344
345 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 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 let mut result = expr_arena.alloc(LogicExpr::BinaryOp {
367 left: original,
368 op: TokenType::And,
369 right: entailed_event,
370 });
371
372 for manner in manner_preds {
374 let manner_sym = interner.intern(manner);
375
376 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 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}