Skip to main content

logicaffeine_language/
transpile.rs

1//! Transpilation from AST to first-order logic notation.
2//!
3//! This module converts the internal AST representation to human-readable
4//! logical formulas in various output formats.
5//!
6//! ## Output Formats
7//!
8//! | Format | Example | Use Case |
9//! |--------|---------|----------|
10//! | **Unicode** | ∀x(Cat(x) → Sleeps(x)) | Terminal display |
11//! | **LaTeX** | `\forall x(Cat(x) \to Sleeps(x))` | Academic papers |
12//! | **ASCII** | `Ax(Cat(x) -> Sleeps(x))` | Plain text |
13//! | **Kripke** | `□(P) @w0` | Modal logic diagrams |
14//!
15//! ## Neo-Davidsonian Events
16//!
17//! Verb semantics use event variables following Davidson's event semantics:
18//!
19//! ```text
20//! "John loves Mary"
21//! → ∃e(Love(e) ∧ Agent(e, john) ∧ Theme(e, mary))
22//! ```
23//!
24//! This representation enables reasoning about event modification,
25//! aspect, and temporal relations.
26
27use std::fmt::Write;
28
29use crate::ast::logic::NumberKind;
30use crate::ast::{LogicExpr, NounPhrase, QuantifierKind, Term};
31use crate::formatter::{
32    KripkeFormatter, LatexFormatter, LogicFormatter, SimpleFOLFormatter, UnicodeFormatter,
33};
34use crate::registry::SymbolRegistry;
35use crate::token::TokenType;
36use crate::{OutputFormat, TranspileContext};
37use logicaffeine_base::{Interner, Symbol};
38
39/// Collect event variables from NeoEvents with suppress_existential=true
40/// Returns unique event variables (coordinated weather verbs share the same var)
41fn collect_suppress_existential_events<'a>(expr: &LogicExpr<'a>) -> Vec<Symbol> {
42    let mut events = Vec::new();
43    collect_suppress_existential_events_inner(expr, &mut events);
44    // Deduplicate - coordinated weather verbs share the same event variable
45    // Symbol is Copy so we can use a simple O(n^2) dedup
46    let mut unique = Vec::new();
47    for e in events {
48        if !unique.iter().any(|x| *x == e) {
49            unique.push(e);
50        }
51    }
52    unique
53}
54
55fn collect_suppress_existential_events_inner<'a>(expr: &LogicExpr<'a>, events: &mut Vec<Symbol>) {
56    match expr {
57        LogicExpr::NeoEvent(data) => {
58            if data.suppress_existential {
59                events.push(data.event_var);
60            }
61        }
62        LogicExpr::BinaryOp { left, right, .. } => {
63            collect_suppress_existential_events_inner(left, events);
64            collect_suppress_existential_events_inner(right, events);
65        }
66        LogicExpr::UnaryOp { operand, .. } => {
67            collect_suppress_existential_events_inner(operand, events);
68        }
69        LogicExpr::Temporal { body, .. } => {
70            collect_suppress_existential_events_inner(body, events);
71        }
72        LogicExpr::TemporalBinary { left, right, .. } => {
73            collect_suppress_existential_events_inner(left, events);
74            collect_suppress_existential_events_inner(right, events);
75        }
76        LogicExpr::Aspectual { body, .. } => {
77            collect_suppress_existential_events_inner(body, events);
78        }
79        LogicExpr::Modal { operand, .. } => {
80            collect_suppress_existential_events_inner(operand, events);
81        }
82        _ => {}
83    }
84}
85
86/// Capitalizes the first character of a string.
87///
88/// Used for predicate names in logic output (e.g., "cat" → "Cat").
89pub fn capitalize_first(s: &str) -> String {
90    let mut chars = s.chars();
91    match chars.next() {
92        None => String::new(),
93        Some(c) => c.to_uppercase().collect::<String>() + chars.as_str(),
94    }
95}
96
97fn write_capitalized<W: Write>(w: &mut W, s: &str) -> std::fmt::Result {
98    let mut chars = s.chars();
99    match chars.next() {
100        None => Ok(()),
101        Some(c) => {
102            for uc in c.to_uppercase() {
103                write!(w, "{}", uc)?;
104            }
105            write!(w, "{}", chars.as_str())
106        }
107    }
108}
109
110impl<'a> NounPhrase<'a> {
111    /// Converts the noun phrase to a short logic symbol (e.g., "C" for "cat").
112    pub fn to_symbol(&self, registry: &mut SymbolRegistry, interner: &Interner) -> String {
113        registry.get_symbol(self.noun, interner)
114    }
115
116    /// Converts the noun phrase to a full logic symbol (e.g., "Cat" for "cat").
117    pub fn to_symbol_full(&self, registry: &SymbolRegistry, interner: &Interner) -> String {
118        registry.get_symbol_full(self.noun, interner)
119    }
120}
121
122impl<'a> Term<'a> {
123    /// Writes the term to a writer using abbreviated symbols.
124    pub fn write_to<W: Write>(
125        &self,
126        w: &mut W,
127        registry: &mut SymbolRegistry,
128        interner: &Interner,
129    ) -> std::fmt::Result {
130        self.write_to_inner(w, registry, interner, false)
131    }
132
133    /// Writes the term to a writer using full (unabbreviated) symbols.
134    pub fn write_to_full<W: Write>(
135        &self,
136        w: &mut W,
137        registry: &mut SymbolRegistry,
138        interner: &Interner,
139    ) -> std::fmt::Result {
140        self.write_to_inner(w, registry, interner, true)
141    }
142
143    /// Writes the term preserving original case (for code generation).
144    pub fn write_to_raw<W: Write>(&self, w: &mut W, interner: &Interner) -> std::fmt::Result {
145        match self {
146            Term::Constant(name) | Term::Variable(name) => {
147                write!(w, "{}", interner.resolve(*name))
148            }
149            Term::Function(name, args) => {
150                write!(w, "{}(", interner.resolve(*name))?;
151                for (i, arg) in args.iter().enumerate() {
152                    if i > 0 {
153                        write!(w, ", ")?;
154                    }
155                    arg.write_to_raw(w, interner)?;
156                }
157                write!(w, ")")
158            }
159            Term::Group(members) => {
160                write!(w, "(")?;
161                for (i, m) in members.iter().enumerate() {
162                    if i > 0 {
163                        write!(w, ", ")?;
164                    }
165                    m.write_to_raw(w, interner)?;
166                }
167                write!(w, ")")
168            }
169            Term::Possessed {
170                possessor,
171                possessed,
172            } => {
173                possessor.write_to_raw(w, interner)?;
174                write!(w, ".{}", interner.resolve(*possessed))
175            }
176            Term::Value { kind, .. } => match kind {
177                NumberKind::Integer(n) => write!(w, "{}", n),
178                NumberKind::Real(f) => write!(w, "{}", f),
179                NumberKind::Symbolic(s) => write!(w, "{}", interner.resolve(*s)),
180            },
181            Term::Sigma(predicate) => write!(w, "σ({})", interner.resolve(*predicate)),
182            Term::Intension(predicate) => write!(w, "^{}", interner.resolve(*predicate)),
183            Term::Kind(kind) => write!(w, "^{}", interner.resolve(*kind)),
184            Term::Proposition(_expr) => write!(w, "[proposition]"),
185        }
186    }
187
188    fn write_to_inner<W: Write>(
189        &self,
190        w: &mut W,
191        registry: &mut SymbolRegistry,
192        interner: &Interner,
193        use_full_names: bool,
194    ) -> std::fmt::Result {
195        match self {
196            Term::Constant(name) => {
197                if use_full_names {
198                    write!(w, "{}", registry.get_symbol_full(*name, interner))
199                } else {
200                    write!(w, "{}", registry.get_symbol(*name, interner))
201                }
202            }
203            Term::Variable(name) => write!(w, "{}", interner.resolve(*name)),
204            Term::Function(name, args) => {
205                let fn_name = if use_full_names {
206                    registry.get_symbol_full(*name, interner)
207                } else {
208                    registry.get_symbol(*name, interner)
209                };
210                write!(w, "{}(", fn_name)?;
211                for (i, arg) in args.iter().enumerate() {
212                    if i > 0 {
213                        write!(w, ", ")?;
214                    }
215                    arg.write_to_inner(w, registry, interner, use_full_names)?;
216                }
217                write!(w, ")")
218            }
219            Term::Group(members) => {
220                for (i, m) in members.iter().enumerate() {
221                    if i > 0 {
222                        write!(w, " ⊕ ")?;
223                    }
224                    m.write_to_inner(w, registry, interner, use_full_names)?;
225                }
226                Ok(())
227            }
228            Term::Possessed {
229                possessor,
230                possessed,
231            } => {
232                let poss_name = if use_full_names {
233                    registry.get_symbol_full(*possessed, interner)
234                } else {
235                    registry.get_symbol(*possessed, interner)
236                };
237                write!(w, "Poss(")?;
238                possessor.write_to_inner(w, registry, interner, use_full_names)?;
239                write!(w, ", {})", poss_name)
240            }
241            Term::Sigma(predicate) => {
242                let pred_name = if use_full_names {
243                    registry.get_symbol_full(*predicate, interner)
244                } else {
245                    registry.get_symbol(*predicate, interner)
246                };
247                write!(w, "σ{}", pred_name)
248            }
249            Term::Intension(predicate) => {
250                // Use full word for intensional terms, not abbreviated symbol
251                let word = interner.resolve(*predicate);
252                let capitalized = word
253                    .chars()
254                    .next()
255                    .map(|c| c.to_uppercase().collect::<String>() + &word[1..])
256                    .unwrap_or_default();
257                write!(w, "^{}", capitalized)
258            }
259            Term::Kind(kind) => {
260                // Kind terms render with the full word, like intensions: ^Tooth.
261                let word = interner.resolve(*kind);
262                let capitalized = word
263                    .chars()
264                    .next()
265                    .map(|c| c.to_uppercase().collect::<String>() + &word[1..])
266                    .unwrap_or_default();
267                write!(w, "^{}", capitalized)
268            }
269            Term::Proposition(expr) => {
270                write!(w, "[")?;
271                expr.write_logic(w, registry, interner, &UnicodeFormatter)?;
272                write!(w, "]")
273            }
274            Term::Value {
275                kind,
276                unit,
277                dimension: _,
278            } => {
279                use crate::ast::NumberKind;
280                match kind {
281                    NumberKind::Real(r) => write!(w, "{}", r)?,
282                    NumberKind::Integer(i) => write!(w, "{}", i)?,
283                    NumberKind::Symbolic(s) => write!(w, "{}", interner.resolve(*s))?,
284                }
285                if let Some(u) = unit {
286                    write!(w, " {}", interner.resolve(*u))?;
287                }
288                Ok(())
289            }
290        }
291    }
292
293    /// Transpiles the term to a logic formula string.
294    pub fn transpile(&self, registry: &mut SymbolRegistry, interner: &Interner) -> String {
295        let mut buf = String::new();
296        let _ = self.write_to(&mut buf, registry, interner);
297        buf
298    }
299}
300
301/// Extracts top-level conjuncts from a discourse (sentences combined with AND).
302/// Returns a vector of individual sentence expressions.
303fn collect_discourse_conjuncts<'a>(expr: &'a LogicExpr<'a>) -> Vec<&'a LogicExpr<'a>> {
304    let mut conjuncts = Vec::new();
305    collect_discourse_conjuncts_inner(expr, &mut conjuncts);
306    conjuncts
307}
308
309fn collect_discourse_conjuncts_inner<'a>(
310    expr: &'a LogicExpr<'a>,
311    conjuncts: &mut Vec<&'a LogicExpr<'a>>,
312) {
313    match expr {
314        LogicExpr::BinaryOp {
315            left,
316            op: TokenType::And,
317            right,
318        } => {
319            // Recursively collect from both sides
320            collect_discourse_conjuncts_inner(left, conjuncts);
321            collect_discourse_conjuncts_inner(right, conjuncts);
322        }
323        _ => {
324            // This is a leaf sentence (not a top-level conjunction)
325            conjuncts.push(expr);
326        }
327    }
328}
329
330impl<'a> LogicExpr<'a> {
331    /// Transpile a discourse (multiple sentences) as numbered formulas.
332    /// If the expression is a top-level conjunction of sentences, formats as:
333    /// ```text
334    /// 1) formula1
335    /// 2) formula2
336    /// 3) formula3
337    /// ```
338    /// If it's a single sentence, just returns the formula without numbering.
339    pub fn transpile_discourse(
340        &self,
341        registry: &mut SymbolRegistry,
342        interner: &Interner,
343        format: OutputFormat,
344    ) -> String {
345        let conjuncts = collect_discourse_conjuncts(self);
346
347        if conjuncts.len() <= 1 {
348            // Single sentence - no numbering needed
349            return self.transpile(registry, interner, format);
350        }
351
352        // Multiple sentences - format as numbered list
353        let mut result = String::new();
354        for (i, conjunct) in conjuncts.iter().enumerate() {
355            if i > 0 {
356                result.push('\n');
357            }
358            let formula = conjunct.transpile(registry, interner, format);
359            result.push_str(&format!("{}) {}", i + 1, formula));
360        }
361        result
362    }
363
364    pub fn write_logic<W: Write, F: LogicFormatter>(
365        &self,
366        w: &mut W,
367        registry: &mut SymbolRegistry,
368        interner: &Interner,
369        fmt: &F,
370    ) -> std::fmt::Result {
371        match self {
372            LogicExpr::Predicate { name, args, world } => {
373                let pred_name = if fmt.use_full_names() {
374                    registry.get_symbol_full(*name, interner)
375                } else {
376                    registry.get_symbol(*name, interner)
377                };
378
379                // If formatter wants world arguments and we have one, append it
380                if fmt.include_world_arguments() {
381                    if let Some(w_sym) = world {
382                        // Build extended args with world variable appended
383                        let mut extended: Vec<Term> = args.to_vec();
384                        extended.push(Term::Variable(*w_sym));
385                        return fmt.write_predicate(w, &pred_name, &extended, registry, interner);
386                    }
387                }
388                fmt.write_predicate(w, &pred_name, args, registry, interner)
389            }
390
391            LogicExpr::Identity { left, right } => {
392                if fmt.wrap_identity() {
393                    write!(w, "(")?;
394                }
395                if fmt.preserve_case() {
396                    left.write_to_raw(w, interner)?;
397                } else if fmt.use_full_names() {
398                    left.write_to_full(w, registry, interner)?;
399                } else {
400                    left.write_to(w, registry, interner)?;
401                }
402                write!(w, "{}", fmt.identity())?;
403                if fmt.preserve_case() {
404                    right.write_to_raw(w, interner)?;
405                } else if fmt.use_full_names() {
406                    right.write_to_full(w, registry, interner)?;
407                } else {
408                    right.write_to(w, registry, interner)?;
409                }
410                if fmt.wrap_identity() {
411                    write!(w, ")")?;
412                }
413                Ok(())
414            }
415
416            LogicExpr::Metaphor { tenor, vehicle } => {
417                write!(w, "Metaphor(")?;
418                tenor.write_to(w, registry, interner)?;
419                write!(w, ", ")?;
420                vehicle.write_to(w, registry, interner)?;
421                write!(w, ")")
422            }
423
424            LogicExpr::Quantifier {
425                kind,
426                variable,
427                body,
428                ..
429            } => {
430                let var_str = interner.resolve(*variable);
431
432                // In SimpleFOL mode, skip event quantifiers (variables named "e" or starting with "e" followed by digits)
433                if fmt.use_simple_events()
434                    && (var_str == "e"
435                        || var_str.starts_with("e")
436                            && var_str[1..].chars().all(|c| c.is_ascii_digit()))
437                {
438                    return body.write_logic(w, registry, interner, fmt);
439                }
440
441                let mut body_buf = String::new();
442                body.write_logic(&mut body_buf, registry, interner, fmt)?;
443                write!(w, "{}", fmt.quantifier(kind, var_str, &body_buf))
444            }
445
446            LogicExpr::Categorical(data) => {
447                let s = if fmt.use_full_names() {
448                    fmt.sanitize(&data.subject.to_symbol_full(registry, interner))
449                } else {
450                    fmt.sanitize(&data.subject.to_symbol(registry, interner))
451                };
452                let p = if fmt.use_full_names() {
453                    fmt.sanitize(&data.predicate.to_symbol_full(registry, interner))
454                } else {
455                    fmt.sanitize(&data.predicate.to_symbol(registry, interner))
456                };
457                match (&data.quantifier, data.copula_negative) {
458                    (TokenType::All, false) => {
459                        write!(w, "{} {} is {}", fmt.categorical_all(), s, p)
460                    }
461                    (TokenType::No, false) => write!(w, "{} {} is {}", fmt.categorical_no(), s, p),
462                    (TokenType::Some, false) => {
463                        write!(w, "{} {} is {}", fmt.categorical_some(), s, p)
464                    }
465                    (TokenType::Some, true) => write!(
466                        w,
467                        "{} {} is {} {}",
468                        fmt.categorical_some(),
469                        s,
470                        fmt.categorical_not(),
471                        p
472                    ),
473                    (TokenType::All, true) => write!(
474                        w,
475                        "{} {} is {} {}",
476                        fmt.categorical_some(),
477                        s,
478                        fmt.categorical_not(),
479                        p
480                    ),
481                    _ => write!(w, "Invalid Syllogism"),
482                }
483            }
484
485            LogicExpr::Relation(data) => {
486                let s = if fmt.use_full_names() {
487                    data.subject.to_symbol_full(registry, interner)
488                } else {
489                    data.subject.to_symbol(registry, interner)
490                };
491                let v = if fmt.use_full_names() {
492                    fmt.sanitize(&registry.get_symbol_full(data.verb, interner))
493                } else {
494                    fmt.sanitize(&registry.get_symbol(data.verb, interner))
495                };
496                let o = if fmt.use_full_names() {
497                    data.object.to_symbol_full(registry, interner)
498                } else {
499                    data.object.to_symbol(registry, interner)
500                };
501                write!(w, "{}({}, {})", v, s, o)
502            }
503
504            LogicExpr::Modal { vector, operand } => {
505                let mut o = String::new();
506                operand.write_logic(&mut o, registry, interner, fmt)?;
507                // An evidential renders by its evidence source (the Kratzer
508                // modal base): Seem(⟨Happy(John)⟩) — never as a bare □/◇,
509                // since the complement is unasserted in every notation.
510                if vector.flavor == crate::ast::ModalFlavor::Evidential {
511                    let source = match vector.modal_base {
512                        Some(base) if fmt.use_full_names() => {
513                            registry.get_symbol_full(base, interner)
514                        }
515                        Some(base) => registry.get_symbol(base, interner),
516                        None => "Seem".to_string(),
517                    };
518                    return write!(w, "{}([{}])", source, o);
519                }
520                write!(w, "{}", fmt.modal(vector.domain, vector.force, &o))
521            }
522
523            LogicExpr::BinaryOp { left, op, right } => {
524                let mut l = String::new();
525                let mut r = String::new();
526                left.write_logic(&mut l, registry, interner, fmt)?;
527                right.write_logic(&mut r, registry, interner, fmt)?;
528
529                // For conditionals (If), check if there are suppress_existential events
530                // that need universal quantification (DRS semantics for generic conditionals)
531                if matches!(op, TokenType::If | TokenType::Implies) {
532                    let events = collect_suppress_existential_events(self);
533                    if !events.is_empty() {
534                        // Wrap with universal quantifiers for each event variable
535                        let mut result = fmt.binary_op(op, &l, &r);
536                        for event_var in events.into_iter().rev() {
537                            let var_str = interner.resolve(event_var);
538                            result = fmt.quantifier(&QuantifierKind::Universal, var_str, &result);
539                        }
540                        return write!(w, "{}", result);
541                    }
542                }
543
544                write!(w, "{}", fmt.binary_op(op, &l, &r))
545            }
546
547            LogicExpr::UnaryOp { op, operand } => {
548                let mut o = String::new();
549                operand.write_logic(&mut o, registry, interner, fmt)?;
550                write!(w, "{}", fmt.unary_op(op, &o))
551            }
552
553            LogicExpr::Temporal { operator, body } => {
554                let mut inner = String::new();
555                body.write_logic(&mut inner, registry, interner, fmt)?;
556                write!(w, "{}", fmt.temporal(operator, &inner))
557            }
558
559            LogicExpr::TemporalBinary {
560                operator,
561                left,
562                right,
563            } => {
564                let mut l = String::new();
565                let mut r = String::new();
566                left.write_logic(&mut l, registry, interner, fmt)?;
567                right.write_logic(&mut r, registry, interner, fmt)?;
568                write!(w, "{}", fmt.temporal_binary(operator, &l, &r))
569            }
570
571            LogicExpr::Aspectual { operator, body } => {
572                let mut inner = String::new();
573                body.write_logic(&mut inner, registry, interner, fmt)?;
574                write!(w, "{}", fmt.aspectual(operator, &inner))
575            }
576
577            LogicExpr::Voice { operator, body } => {
578                let mut inner = String::new();
579                body.write_logic(&mut inner, registry, interner, fmt)?;
580                write!(w, "{}", fmt.voice(operator, &inner))
581            }
582
583            LogicExpr::Question { wh_variable, body } => {
584                let mut body_str = String::new();
585                body.write_logic(&mut body_str, registry, interner, fmt)?;
586                write!(
587                    w,
588                    "{}",
589                    fmt.lambda(interner.resolve(*wh_variable), &body_str)
590                )
591            }
592
593            LogicExpr::YesNoQuestion { body } => {
594                write!(w, "?")?;
595                body.write_logic(w, registry, interner, fmt)
596            }
597
598            LogicExpr::Atom(s) => {
599                let name = if fmt.preserve_case() {
600                    interner.resolve(*s).to_string()
601                } else if fmt.use_full_names() {
602                    registry.get_symbol_full(*s, interner)
603                } else {
604                    registry.get_symbol(*s, interner)
605                };
606                write!(w, "{}", fmt.sanitize(&name))
607            }
608
609            LogicExpr::Lambda { variable, body } => {
610                let mut b = String::new();
611                body.write_logic(&mut b, registry, interner, fmt)?;
612                write!(w, "{}", fmt.lambda(interner.resolve(*variable), &b))
613            }
614
615            LogicExpr::App { function, argument } => {
616                write!(w, "(")?;
617                function.write_logic(w, registry, interner, fmt)?;
618                write!(w, ")(")?;
619                argument.write_logic(w, registry, interner, fmt)?;
620                write!(w, ")")
621            }
622
623            LogicExpr::Intensional { operator, content } => {
624                write!(
625                    w,
626                    "{}[",
627                    fmt.sanitize(&registry.get_symbol(*operator, interner))
628                )?;
629                content.write_logic(w, registry, interner, fmt)?;
630                write!(w, "]")
631            }
632
633            LogicExpr::Event { predicate, adverbs } => {
634                let mut pred_str = String::new();
635                predicate.write_logic(&mut pred_str, registry, interner, fmt)?;
636                let adverb_preds: Vec<String> = adverbs
637                    .iter()
638                    .map(|a| format!("{}(e)", fmt.sanitize(&registry.get_symbol(*a, interner))))
639                    .collect();
640                write!(w, "{}", fmt.event_quantifier(&pred_str, &adverb_preds))
641            }
642
643            LogicExpr::NeoEvent(data) => {
644                use crate::ast::{QuantifierKind, ThematicRole};
645
646                if fmt.use_simple_events() {
647                    // A tense locates the event, not a participant: it wraps the flattened
648                    // formula (`Past(Run(John) ∧ Quickly(John))`) instead of reattaching like an
649                    // adverb, which would say that John is past.
650                    let tenses: Vec<&'static str> = data
651                        .modifiers
652                        .iter()
653                        .filter_map(|m| match interner.resolve(*m) {
654                            "Past" => Some(fmt.past()),
655                            "Future" => Some(fmt.future()),
656                            _ => None,
657                        })
658                        .collect();
659                    for tense in &tenses {
660                        write!(w, "{tense}(")?;
661                    }
662                    write!(w, "{}", registry.get_symbol_full(data.verb, interner))?;
663                    write!(w, "(")?;
664                    let mut first = true;
665                    let mut subject_term = None;
666                    for (role, term) in data.roles.iter() {
667                        // Include core thematic roles in SimpleFOL output
668                        if matches!(
669                            role,
670                            ThematicRole::Agent
671                                | ThematicRole::Patient
672                                | ThematicRole::Theme
673                                | ThematicRole::Goal
674                                | ThematicRole::Location
675                        ) {
676                            if !first {
677                                write!(w, ", ")?;
678                            }
679                            first = false;
680                            term.write_to_full(w, registry, interner)?;
681                            // The adverb reattaches to the agent (or the first core
682                            // participant when there is no agent).
683                            if subject_term.is_none() || matches!(role, ThematicRole::Agent) {
684                                subject_term = Some(term);
685                            }
686                        }
687                    }
688                    write!(w, ")")?;
689                    // Flattening the event drops the ∃e binder, so an adverbial
690                    // modifier `Loudly(e)` must reattach to the participant, or it is
691                    // silently lost: ∃e(Bark(e) ∧ Agent(e,y) ∧ Loudly(e)) ⇒ Bark(y) ∧ Loudly(y).
692                    for mod_sym in data
693                        .modifiers
694                        .iter()
695                        .filter(|m| !matches!(interner.resolve(**m), "Past" | "Future"))
696                    {
697                        write!(w, " {} ", fmt.and())?;
698                        write_capitalized(w, interner.resolve(*mod_sym))?;
699                        write!(w, "(")?;
700                        if let Some(term) = subject_term {
701                            term.write_to_full(w, registry, interner)?;
702                        }
703                        write!(w, ")")?;
704                    }
705                    for _ in &tenses {
706                        write!(w, ")")?;
707                    }
708                    Ok(())
709                } else {
710                    let e = interner.resolve(data.event_var);
711                    let mut body = String::new();
712
713                    // Get world argument suffix if Kripke format
714                    let world_suffix = if fmt.include_world_arguments() {
715                        data.world
716                            .map(|w| format!(", {}", interner.resolve(w)))
717                            .unwrap_or_default()
718                    } else {
719                        String::new()
720                    };
721
722                    write_capitalized(&mut body, interner.resolve(data.verb))?;
723                    write!(body, "({}{})", e, world_suffix)?;
724                    for (role, term) in data.roles.iter() {
725                        let role_str = role.name();
726                        write!(body, " {} {}({}, ", fmt.and(), role_str, e)?;
727                        if fmt.use_full_names() {
728                            term.write_to_full(&mut body, registry, interner)?;
729                        } else {
730                            term.write_to(&mut body, registry, interner)?;
731                        }
732                        write!(body, "{})", world_suffix)?;
733                    }
734                    for mod_sym in data.modifiers.iter() {
735                        write!(body, " {} ", fmt.and())?;
736                        write_capitalized(&mut body, interner.resolve(*mod_sym))?;
737                        write!(body, "({}{})", e, world_suffix)?;
738                    }
739                    if data.suppress_existential {
740                        // Event var will be bound by outer ∀ from DRS (generic conditionals)
741                        write!(w, "{}", body)
742                    } else {
743                        // Normal case: emit ∃e(...)
744                        write!(
745                            w,
746                            "{}",
747                            fmt.quantifier(&QuantifierKind::Existential, e, &body)
748                        )
749                    }
750                }
751            }
752
753            LogicExpr::Imperative { action } => {
754                // Directive(hearer, ⟨action⟩) — the commanded action is the
755                // content of an obligation on the addressee (§1.4), not an
756                // asserted event. The addressee is the action's Agent role
757                // (Addressee, or Us for hortative "let's").
758                use crate::ast::ThematicRole;
759                fn directive_agent<'b>(e: &'b LogicExpr<'b>) -> Option<&'b Term<'b>> {
760                    match e {
761                        LogicExpr::NeoEvent(data) => data
762                            .roles
763                            .iter()
764                            .find(|(role, _)| matches!(role, ThematicRole::Agent))
765                            .map(|(_, term)| term),
766                        LogicExpr::UnaryOp { operand, .. } => directive_agent(operand),
767                        LogicExpr::Quantifier { body, .. } => directive_agent(body),
768                        LogicExpr::BinaryOp { left, .. } => directive_agent(left),
769                        _ => None,
770                    }
771                }
772                let mut addressee = String::new();
773                match directive_agent(action) {
774                    Some(t) if fmt.use_full_names() => {
775                        t.write_to_full(&mut addressee, registry, interner)?
776                    }
777                    Some(t) => t.write_to(&mut addressee, registry, interner)?,
778                    None => addressee.push_str("Addressee"),
779                }
780                let mut a = String::new();
781                action.write_logic(&mut a, registry, interner, fmt)?;
782                write!(w, "Directive({}, [{}])", addressee, a)
783            }
784
785            LogicExpr::Exclamative { degree_var, body } => {
786                // Exclaim(∃d(body ∧ d ≫ θ)): a surprisingly-high degree.
787                let d = interner.resolve(*degree_var);
788                write!(w, "Exclaim(∃{}(", d)?;
789                body.write_logic(w, registry, interner, fmt)?;
790                write!(w, " {} {} ≫ θ))", fmt.and(), d)
791            }
792
793            LogicExpr::Optative { wish } => {
794                // Wish(Speaker, ⟨wish⟩): the complement is not asserted.
795                write!(w, "Wish(Speaker, ⟨")?;
796                wish.write_logic(w, registry, interner, fmt)?;
797                write!(w, "⟩)")
798            }
799
800            LogicExpr::Implicature {
801                assertion,
802                implicature,
803            } => {
804                // assertion +> Implicature(…): literal meaning, then the cancellable
805                // scalar implicature (the defeasible part).
806                assertion.write_logic(w, registry, interner, fmt)?;
807                write!(w, " +> Implicature(")?;
808                implicature.write_logic(w, registry, interner, fmt)?;
809                write!(w, ")")
810            }
811
812            LogicExpr::SpeechAct {
813                performer,
814                act_type,
815                content,
816            } => {
817                // Render the performer with its full name (e.g. Speaker), matching the
818                // role constants used inside the content, rather than an abbreviation.
819                write!(
820                    w,
821                    "SpeechAct({}, {}, ",
822                    interner.resolve(*act_type),
823                    fmt.sanitize(&registry.get_symbol_full(*performer, interner))
824                )?;
825                content.write_logic(w, registry, interner, fmt)?;
826                write!(w, ")")
827            }
828
829            LogicExpr::Counterfactual {
830                antecedent,
831                consequent,
832            } => {
833                let mut a = String::new();
834                let mut c = String::new();
835                antecedent.write_logic(&mut a, registry, interner, fmt)?;
836                consequent.write_logic(&mut c, registry, interner, fmt)?;
837                write!(w, "{}", fmt.counterfactual(&a, &c))
838            }
839
840            LogicExpr::Causal { effect, cause } => {
841                write!(w, "Cause(")?;
842                cause.write_logic(w, registry, interner, fmt)?;
843                write!(w, ", ")?;
844                effect.write_logic(w, registry, interner, fmt)?;
845                write!(w, ")")
846            }
847
848            LogicExpr::Concessive { main, concession } => {
849                // main ∧ Concessive(concession): the main holds despite the concession.
850                main.write_logic(w, registry, interner, fmt)?;
851                write!(w, " {} Concessive(", fmt.and())?;
852                concession.write_logic(w, registry, interner, fmt)?;
853                write!(w, ")")
854            }
855
856            LogicExpr::Comparative {
857                adjective,
858                subject,
859                object,
860                difference,
861                relation,
862            } => {
863                use crate::ast::ComparisonRelation;
864                // Equatives render as a max-degree at-least/equality comparison:
865                // "John is as tall as Mary." → max{d:Tall(John,d)} ≥ max{d:Tall(Mary,d)}.
866                if !matches!(relation, ComparisonRelation::Greater) {
867                    let rel = if matches!(relation, ComparisonRelation::Equal) {
868                        "="
869                    } else {
870                        "≥"
871                    };
872                    let adj = interner.resolve(*adjective);
873                    let mut s = String::new();
874                    subject.write_to(&mut s, registry, interner)?;
875                    let mut o = String::new();
876                    object.write_to(&mut o, registry, interner)?;
877                    let cap = adj
878                        .chars()
879                        .next()
880                        .map(|c| c.to_uppercase().collect::<String>() + &adj[1..])
881                        .unwrap_or_default();
882                    return write!(
883                        w,
884                        "max{{d:{}({},d)}} {} max{{d:{}({},d)}}",
885                        cap, s, rel, cap, o
886                    );
887                }
888                let adj = interner.resolve(*adjective);
889                let mut subj_buf = String::new();
890                if fmt.preserve_case() {
891                    subject.write_to_raw(&mut subj_buf, interner)?;
892                } else if fmt.use_full_names() {
893                    subject.write_to_full(&mut subj_buf, registry, interner)?;
894                } else {
895                    subject.write_to(&mut subj_buf, registry, interner)?;
896                }
897                let mut obj_buf = String::new();
898                if fmt.preserve_case() {
899                    object.write_to_raw(&mut obj_buf, interner)?;
900                } else if fmt.use_full_names() {
901                    object.write_to_full(&mut obj_buf, registry, interner)?;
902                } else {
903                    object.write_to(&mut obj_buf, registry, interner)?;
904                }
905                let diff_str = if let Some(diff) = difference {
906                    let mut diff_buf = String::new();
907                    if fmt.preserve_case() {
908                        diff.write_to_raw(&mut diff_buf, interner)?;
909                    } else if fmt.use_full_names() {
910                        diff.write_to_full(&mut diff_buf, registry, interner)?;
911                    } else {
912                        diff.write_to(&mut diff_buf, registry, interner)?;
913                    }
914                    Some(diff_buf)
915                } else {
916                    None
917                };
918                fmt.write_comparative(w, adj, &subj_buf, &obj_buf, diff_str.as_deref())
919            }
920
921            LogicExpr::Superlative {
922                adjective,
923                subject,
924                domain,
925            } => {
926                let mut s = String::new();
927                subject.write_to(&mut s, registry, interner)?;
928                let mut d = String::new();
929                write_capitalized(&mut d, interner.resolve(*domain))?;
930                let comp = format!("{}er", interner.resolve(*adjective));
931                write!(w, "{}", fmt.superlative(&comp, &d, &s))
932            }
933
934            LogicExpr::Scopal { operator, body } => {
935                write!(w, "{}(", interner.resolve(*operator))?;
936                body.write_logic(w, registry, interner, fmt)?;
937                write!(w, ")")
938            }
939
940            LogicExpr::TemporalAnchor { anchor, body } => {
941                write!(w, "{}(", interner.resolve(*anchor))?;
942                body.write_logic(w, registry, interner, fmt)?;
943                write!(w, ")")
944            }
945
946            LogicExpr::Control {
947                verb,
948                subject,
949                object,
950                infinitive,
951            } => {
952                write!(
953                    w,
954                    "{}(",
955                    fmt.sanitize(&registry.get_symbol(*verb, interner))
956                )?;
957                subject.write_to(w, registry, interner)?;
958                if let Some(obj) = object {
959                    write!(w, ", ")?;
960                    obj.write_to(w, registry, interner)?;
961                }
962                write!(w, ", ")?;
963                infinitive.write_logic(w, registry, interner, fmt)?;
964                write!(w, ")")
965            }
966
967            LogicExpr::Presupposition {
968                assertion,
969                presupposition,
970            } => {
971                assertion.write_logic(w, registry, interner, fmt)?;
972                write!(w, " [Presup: ")?;
973                presupposition.write_logic(w, registry, interner, fmt)?;
974                write!(w, "]")
975            }
976
977            LogicExpr::Focus {
978                kind,
979                focused,
980                scope,
981            } => {
982                use crate::token::FocusKind;
983                let prefix = match kind {
984                    FocusKind::Only => "Only",
985                    FocusKind::Even => "Even",
986                    FocusKind::Just => "Just",
987                    FocusKind::Cleft => "Cleft",
988                };
989                write!(w, "{}(", prefix)?;
990                focused.write_to(w, registry, interner)?;
991                write!(w, ", ")?;
992                scope.write_logic(w, registry, interner, fmt)?;
993                write!(w, ")")
994            }
995
996            LogicExpr::Distributive { predicate } => {
997                write!(w, "*")?;
998                predicate.write_logic(w, registry, interner, fmt)
999            }
1000
1001            LogicExpr::GroupQuantifier {
1002                group_var,
1003                count,
1004                member_var,
1005                restriction,
1006                body,
1007            } => {
1008                let g = interner.resolve(*group_var);
1009                let x = interner.resolve(*member_var);
1010
1011                // ∃g(Group(g) ∧ Count(g,n) ∧ ∀x(Member(x,g) → restriction) ∧ body)
1012                write!(
1013                    w,
1014                    "{}{}(Group({}) {} Count({}, {}) {} {}{}(Member({}, {}) {} ",
1015                    fmt.existential(),
1016                    g,
1017                    g,
1018                    fmt.and(),
1019                    g,
1020                    count,
1021                    fmt.and(),
1022                    fmt.universal(),
1023                    x,
1024                    x,
1025                    g,
1026                    fmt.implies()
1027                )?;
1028
1029                restriction.write_logic(w, registry, interner, fmt)?;
1030
1031                write!(w, ") {} ", fmt.and())?;
1032
1033                body.write_logic(w, registry, interner, fmt)?;
1034
1035                write!(w, ")")
1036            }
1037        }
1038    }
1039
1040    /// Transpiles to a logic formula string using a custom formatter.
1041    pub fn transpile_with<F: LogicFormatter>(
1042        &self,
1043        registry: &mut SymbolRegistry,
1044        interner: &Interner,
1045        fmt: &F,
1046    ) -> String {
1047        let mut buf = String::new();
1048        let _ = self.write_logic(&mut buf, registry, interner, fmt);
1049        buf
1050    }
1051
1052    /// Transpiles to a logic formula string in the specified output format.
1053    ///
1054    /// # Formats
1055    ///
1056    /// - [`OutputFormat::Unicode`]: ∀x(Cat(x) → Sleeps(x))
1057    /// - [`OutputFormat::LaTeX`]: `\forall x(Cat(x) \to Sleeps(x))`
1058    /// - [`OutputFormat::SimpleFOL`]: Ax(Cat(x) -> Sleeps(x))
1059    /// - [`OutputFormat::Kripke`]: □(P) @w0
1060    pub fn transpile(
1061        &self,
1062        registry: &mut SymbolRegistry,
1063        interner: &Interner,
1064        format: OutputFormat,
1065    ) -> String {
1066        match format {
1067            OutputFormat::Unicode => self.transpile_with(registry, interner, &UnicodeFormatter),
1068            OutputFormat::LaTeX => self.transpile_with(registry, interner, &LatexFormatter),
1069            OutputFormat::SimpleFOL => self.transpile_with(registry, interner, &SimpleFOLFormatter),
1070            OutputFormat::Kripke => self.transpile_with(registry, interner, &KripkeFormatter),
1071        }
1072    }
1073
1074    /// Transpiles using a [`TranspileContext`] and custom formatter.
1075    pub fn transpile_ctx<F: LogicFormatter>(
1076        &self,
1077        ctx: &mut TranspileContext<'_>,
1078        fmt: &F,
1079    ) -> String {
1080        self.transpile_with(ctx.registry, ctx.interner, fmt)
1081    }
1082
1083    /// Transpiles to Unicode format using a [`TranspileContext`].
1084    pub fn transpile_ctx_unicode(&self, ctx: &mut TranspileContext<'_>) -> String {
1085        self.transpile_ctx(ctx, &UnicodeFormatter)
1086    }
1087
1088    /// Transpiles to LaTeX format using a [`TranspileContext`].
1089    pub fn transpile_ctx_latex(&self, ctx: &mut TranspileContext<'_>) -> String {
1090        self.transpile_ctx(ctx, &LatexFormatter)
1091    }
1092}