LOGicalThought: Neurosymbolic High-Assurance Reasoning

• LOGicalThought is a neurosymbolic framework that fuses large language models with formal logic to yield verifiable and evidence-grounded reasoning in regulated domains.
• It employs a dual-context architecture, using a symbolic graph for rule extraction and a logic-based context for executable inference to ensure transparent decision paths.
• The framework achieves notable performance improvements in legal and biomedical benchmarks by robustly addressing negation, implication, and defeasible reasoning.

Searching arXiv for papers on LOGicalThought / Logic-of-Thought to ground the article. arxiv_search(query="LOGicalThought Logic-Based Ontological Grounding of LLMs for High-Assurance Reasoning", max_results=5) arxiv_search(query="Logic-of-Thought Injecting Logic into Contexts for Full Reasoning in LLMs", max_results=5) LOGicalThought (LogT) is a neurosymbolic framework for high-assurance reasoning with LLMs in domains such as law and medicine, where conclusions are expected to be accurate, verifiable, and explicitly grounded in evidence. It combines an LLM with an advanced logical language and the ErgoAI reasoner to build two compact intermediate representations—a symbolic graph context and a logic-based context—from long-form guideline documents, scenarios, and hypotheses. The resulting system reframes inference over dense guidelines as grounded evaluation over curated symbolic artifacts and executable non-monotonic rules, with explicit attention to negation, implication, defeasible rules, exceptions, and override relationships (Nananukul et al., 2 Oct 2025).

1. Conceptual scope and motivation

LogT is designed for settings in which ordinary open-ended language modeling is insufficient. The target use cases include tax law, statutory interpretation, contract analysis, and biomedical trial eligibility, all of which require reasoning that is evidence-based and formally inspectable rather than merely plausible (Nananukul et al., 2 Oct 2025). The motivating claim is that high-assurance text commonly encodes non-monotonic structure: a general rule may hold by default, yet a single exception can invalidate it. This makes the reasoning problem qualitatively different from standard natural-language inference.

The framework addresses several limitations attributed to ordinary prompting methods. Chain-of-Thought can produce step-by-step explanations, but these remain natural-language narratives rather than formally grounded deductions. Long guideline documents also bury relevant rules among substantial irrelevant material, and standard LLM inference can miss precise exceptions or fail to maintain rule priority. LogT therefore treats negation, implication, and defeasible reasoning not as incidental phenomena but as explicit reasoning modes to be modeled structurally (Nananukul et al., 2 Oct 2025).

The overall task is defined over a guideline document $X$, a scenario $S$, and a hypothesis $H$, with the predicted relation

$\hat{L} = \operatorname{M}(f(X,S,H)),$

where

$$\hat{L} \in \{\text{Entailment},\text{Contradiction},\text{Neutral}\}.$$

Here $f$ extracts logic-program-style rules from the natural-language inputs (Nananukul et al., 2 Oct 2025).

2. Reasoning modes and formal orientation

The framework concentrates on three reasoning modes. In the negation case, the relevant rules are of the form $r_i:\ \neg q_i \leftarrow p_i$, corresponding to explicit prohibitions or direct negative consequences. In the implication case, the rules are of the form $r_i:\ q_i \leftarrow p_i$, corresponding to ordinary conditional inference. In the defeasible case, a general rule $q_i \leftarrow p_i$ is paired with an exception yielding $\neg q_i$, together with an explicit override relation indicating that the exception defeats the default (Nananukul et al., 2 Oct 2025).

This focus is narrower than a full theory of legal or medical reasoning. The paper explicitly states that the three modes are non-exhaustive. Nonetheless, they are presented as core structures that recur in high-assurance text and that remain difficult for standard LLM inference (Nananukul et al., 2 Oct 2025).

The logical language used by LogT is not limited to monotonic Horn-style deduction. Facts are represented as atomic predicates; rules are Horn-like implications; defeasible rules are overridable; and precedence is encoded through explicit override relations such as overrides(penguin_rule, bird_rule) in the appendix examples (Nananukul et al., 2 Oct 2025). ErgoAI is employed because it supports higher-order logic, non-monotonic reasoning, defeasible logic, and exception handling.

A common simplification is to treat LogT as merely “logic prompting.” That description is incomplete. The framework does use LLMs for extraction and synthesis, but its defining commitment is to executable logic plus symbolic grounding, not only to natural-language prompt engineering. This suggests that LogT belongs more naturally to the neurosymbolic tradition than to prompt-only reasoning schemes.

3. Three-stage architecture

LogT proceeds through three stages: symbolic context generation, logic-based context construction, and hypothesis evaluation (Nananukul et al., 2 Oct 2025).

In the first stage, the system performs rule selection: $S$0 Only the subset of guideline rules deemed relevant to the current scenario and hypothesis is retained. From $S$1, $S$2, and $S$3, the system constructs three symbolic components: a guideline ontology $S$4, knowledge triples $S$5, and natural-language queries $S$6. These are grouped into the symbolic graph context

$S$7

The ontology captures concepts, relations, hierarchical dependencies, and rule structure; the triples encode subject–predicate–object information from the scenario and hypothesis; and the natural-language queries decompose the hypothesis into reasoning subquestions (Nananukul et al., 2 Oct 2025).

In the second stage, the symbolic graph context is converted into an executable ErgoAI program. Facts are synthesized from instance triples,

$S$8

while rules and defeasible overrides are synthesized from the ontology,

$S$9

Natural-language queries are translated into formal queries,

$H$0

and the program is assembled as

$H$1

Because LLM-generated logic may contain syntactic defects, LogT applies rule-based syntactic correction, ErgoAI compilation, and filtering to keep only compilable fragments: $H$2 ErgoAI then executes the queries,

$H$3

producing the logic-based context

$H$4

If query compilation fails, the system falls back to the verified program $H$5 alone (Nananukul et al., 2 Oct 2025).

In the final stage, the LLM receives $H$6, $H$7, and $H$8, and predicts

$H$9

where $\hat{L} = \operatorname{M}(f(X,S,H)),$0 is the label and $\hat{L} = \operatorname{M}(f(X,S,H)),$1 is the raw reasoning trace (Nananukul et al., 2 Oct 2025).

4. Dual context and trace structure

The dual-context design is the central architectural novelty. The symbolic graph context acts as a blueprint: it narrows the input to relevant rules, exposes ontology structure, and aligns facts and queries with the language of the source guidelines. The logic-based context provides executable inference, exception handling, and syntactic verification through ErgoAI. Together they convert long-form inference into compact grounded evaluation (Nananukul et al., 2 Oct 2025).

The framework therefore distributes responsibility across components. The LLM handles language understanding, rule selection, and synthesis; the symbolic graph organizes the relevant conceptual structure; the logic program carries out formal reasoning; and the final LLM step produces a grounded entailment judgment rather than an answer derived directly from raw guideline text. This suggests a different division of labor from ordinary retrieval-augmented or Chain-of-Thought pipelines.

The reasoning trace is subsequently normalized into six trace types: fact_lookup, apply_rule, check_condition, resolve_conflict/override, contradiction_detected, and conclude_label. The paper describes this normalization as an LLM-as-a-judge style process (Nananukul et al., 2 Oct 2025). The resulting traces are intended to be more inspectable than unconstrained natural-language explanations because they are anchored in explicit facts, rules, and override relations.

5. Benchmarks, baselines, and reported performance

LogT is evaluated on four benchmarks spanning legal and biomedical reasoning, along with a hand-crafted rulebook benchmark (Nananukul et al., 2 Oct 2025).

Benchmark	Domain
ContractNLI	legal domain; document-level NLI over contracts
SARA	statutory reasoning over the U.S. Internal Revenue Code
BioMedNLI	biomedical / clinical trial reasoning
Dungeons and Dragons NLI	hand-crafted benchmark based on D&D rulebook logic

To stress the three reasoning modes, the benchmarks were enhanced using 11 prompt templates, including Negation_Flip, Negation_Maintain, Causality_Entailment, Causality_Contradiction, NotMentioned_Defeasibility, Entailment_Defeasibility, Contradiction_Defeasibility, Defeasibility_Entailment, and Defeasibility_Contradiction. Validation combined heuristic keyword or regex checks, pretrained NLI models, and manual audit of 100 sampled examples per benchmark (Nananukul et al., 2 Oct 2025).

The baselines are Basic Prompting No Document, Basic Prompting with Document, Few-Shot Prompting, and Chain-of-Thought. The paper also reports ablations: LogT (SGC), LogT (LC), and LogT (Full). The six evaluated models are Mistral Instruct v0.3 7B, LLaMA 3.1 8B, LLaMA 3.3 70B, Claude 3.5 Haiku, GPT-o3 Mini, and DeepSeek R1. The reported inference temperature is $\hat{L} = \operatorname{M}(f(X,S,H)),$2, reasoning generation temperature is $\hat{L} = \operatorname{M}(f(X,S,H)),$3, the seed is 42, and the maximum token budget is 4096 (Nananukul et al., 2 Oct 2025).

The headline empirical result is an overall improvement of 11.84% across all LLMs; the results section also reports 11.82% over the average of all baselines and 4.41% over the best baseline, with the abstract and results section treated as effectively reporting the same overall gain (Nananukul et al., 2 Oct 2025). Relative to the strongest baseline, performance improves by up to +10.2% on negation, +13.2% on implication, and +5.5% on defeasible reasoning. The strongest and most consistent gains are reported for implication reasoning, with benchmark-level implication gains up to +2.2% on ContractNLI, +5.0% on SARA, +10.8% on BioMedNLI, and +13.2% on Dungeons and Dragons (Nananukul et al., 2 Oct 2025).

The ablations indicate that logic-based context is more valuable than symbolic graph context alone: LC yields about +2.4% over CoT, SGC alone about +0.5%, and Full LogT about +7.4% on average. Smaller models are reported to benefit especially strongly. On ContractNLI, for example, Mistral improves from 45.20% to 53.40%, and LLaMA 8B improves from 44.30% to 50.40% (Nananukul et al., 2 Oct 2025).

6. Relation to other logic-centered prompting and known limitations

LogT is closely related in theme, but not identical in method, to the earlier “Logic-of-Thought” (LoT) prompting framework (Liu et al., 2024). LoT extracts propositions and logical expressions from the input, expands them using propositional laws such as double negation, contraposition, and transitivity, translates the derived expressions back into natural language, and appends them to the original prompt context. It is explicitly described as orthogonal to Chain-of-Thought, Self-Consistency, CoT-SC, and Tree-of-Thoughts, and it reports improvements such as +4.35% over CoT on ReClor, +3.52% over CoT-SC on RuleTaker, and +8% over ToT on ProofWriter (Liu et al., 2024).

The distinction is consequential. LoT is a prompting framework centered on propositional context augmentation, whereas LogT is a neurosymbolic architecture centered on symbolic graph construction, compilation into an executable non-monotonic logic program, and final hypothesis evaluation over dual contexts. A plausible implication is that LogT is aimed less at generic logical QA and more at auditable reasoning over long-form guidelines where defeasibility and override structure are indispensable.

The limitations reported for LogT are correspondingly structural. The three reasoning modes are non-exhaustive; LLM synthesis can introduce syntax errors; non-compilable fragments may be discarded; and performance can vary by dataset or mode, with small drops noted for SARA negation, ContractNLI defeasible reasoning, and BioMedNLI negation (Nananukul et al., 2 Oct 2025). The enhanced benchmarks themselves depend on automated hypothesis generation and validation, which the paper presents as careful but still benchmark-construction machinery rather than naturally occurring test data.

Reasoning trace analysis also reveals the intended trade-off. LogT produces about 21.5% more reasoning steps than CoT on average, with apply_rule increasing from 1.08 to 2.66 and fact_lookup from 2.73 to 2.90. Correct reasoning traces are reported for 89% of LogT’s correct predictions, compared with 85% for CoT overall (Nananukul et al., 2 Oct 2025). These results do not establish perfect faithfulness, but they support the narrower claim that forcing inference through symbolic and logical artifacts yields more inspectable and better-aligned reasoning than unconstrained natural-language explanation.

In this sense, LogT exemplifies a specific approach to high-assurance LLM reasoning: not replacing LLMs with symbolic systems, and not merely prompting them to “reason better,” but grounding their judgments in a curated ontology, executable defeasible logic, and explicit provenance paths from source rule to final label (Nananukul et al., 2 Oct 2025).