Making Implicit Premises Explicit in Logical Understanding of Enthymemes

This paper proposes a neuro-symbolic pipeline that integrates large language models for generating implicit premises and translating natural language into logical formulas, alongside a SAT-based reasoner, to systematically decode enthymemes and verify logical entailment, demonstrating promising performance on existing datasets.

The Gist

Imagine you are a detective trying to solve a mystery, but the witness gives you a clue that feels incomplete.

The Witness says: "The window is broken, and there's a baseball on the floor."
The Detective concludes: "Someone threw the ball through the window."

In the real world, we instantly fill in the missing piece: Baseballs break windows. But in the world of computers, that missing piece is a huge problem. The computer sees "Window broken" and "Ball on floor" and doesn't know how to jump to "Someone threw the ball." It's missing the invisible bridge.

This paper is about building a machine that can not only spot that invisible bridge but also build it, translate it into a language the computer understands, and prove it works.

Here is the breakdown of their solution, using a simple analogy.

The Problem: The "Enthymeme"

In logic, an argument with a missing piece is called an enthymeme.

• Explicit Premise: The facts we see (Window broken).
• Claim: The conclusion (Someone threw the ball).
• Implicit Premise: The missing logic (Baseballs break windows).

Current computers are bad at this. Some can guess the missing word (like a spellchecker), but they don't understand the logic. Others can do the logic, but they need a giant library of rules to start with, which doesn't exist for every situation.

The Solution: A Three-Step Detective Pipeline

The authors built a "Neuro-Symbolic Pipeline." Think of this as a three-person detective team working together to solve the case.

Step 1: The Creative Writer (The LLM)

Role: Fills in the missing gaps.
How it works: You give the computer the facts and the conclusion. The computer (using a Large Language Model, like a super-smart AI writer) asks, "What story connects these?"

• Input: "Window broken" + "Someone threw the ball."
• Output: "Baseballs are hard and windows are fragile."
  The AI generates this missing "bridge" in plain English. It might even generate a chain of bridges (Step 1, Step 2, Step 3) to make the logic very clear.

Step 2: The Translator (AMR & Logic)

Role: Turns the story into a strict code.
How it works: Computers can't argue with sentences; they need math. This step takes the English sentences from Step 1 and translates them into Abstract Meaning Representation (AMR).

• Imagine AMR is like a flowchart of the sentence's meaning, ignoring grammar and focusing on who did what to whom.
• Then, it translates that flowchart into Propositional Logic (mathematical formulas like $A \land B \rightarrow C$).
• Why? This turns a fuzzy story into a rigid structure that a calculator can check.

Step 3: The Strict Judge (The Reasoner)

Role: Checks if the math adds up.
How it works: This is where the "Neuro-Symbolic" magic happens.

• The "Neuro" part: The computer knows that "walking" and "moving" are similar, even if the words are different. It uses a "similarity score" (like a vibe check) to say, "These two concepts are close enough to be treated as the same."
• The "Symbolic" part: It uses a SAT solver (a super-fast logic checker) to run the math. It asks: "If I combine the Premise + the Missing Bridge, does the Conclusion have to be true?"
• If the math says "Yes," the argument is valid. If "No," the bridge is broken.

Why is this cool? (The "Relaxation" Trick)

Real life is messy. "Walking" isn't exactly the same as "moving," but for the sake of the argument, they are close enough.
The paper introduces a clever trick called Relaxation.

• Imagine you are trying to fit a square peg in a round hole. A strict computer says "No."
• This system says, "Wait, let's sand down the corners of the square peg just a little bit (using AI similarity scores) so it fits."
• It allows the computer to be slightly flexible with language while still being strict with the logic.

The Results: Does it work?

The team tested this on two big datasets of tricky arguments (ARCT and ANLI).

• The Finding: The more steps of "missing logic" the AI generated, the better it got.
• The Analogy: If you ask a human to explain a jump, saying "He jumped" is okay. Saying "He ran, bent his knees, and pushed off the ground" is much better. The AI that generated three steps of missing logic performed the best. It proved that breaking a complex argument into smaller, explicit steps helps the computer understand the whole picture.

The Big Picture

This paper is a bridge between Human Intuition (we know what's missing) and Computer Rigor (we need exact math).

Before this, computers were either:

1. Too fuzzy: They guessed the missing words but couldn't prove the logic.
2. Too rigid: They could prove logic but needed a pre-written rulebook for everything.

This new pipeline is like a smart translator that listens to a human story, fills in the missing chapters, translates the whole book into a math equation, and then solves the equation to prove the story makes sense. It's a major step toward computers that can truly understand human arguments, not just the words we use.

Technical Summary

Here is a detailed technical summary of the paper "Making Implicit Premises Explicit in Logical Understanding of Enthymemes" by Xuyao Feng and Anthony Hunter.

1. Problem Statement

Real-world arguments often take the form of enthymemes, where premises and/or claims are left implicit. While Natural Language Processing (NLP) methods can identify enthymemes in text, they typically fail to decode the underlying logical structure. Conversely, symbolic logic-based approaches can decode enthymemes via abduction (identifying missing premises) but rely on pre-existing, sufficiently large knowledge bases of logical formulas, which are rarely available for free-text arguments.

The Gap: There is a lack of a systematic method to:

1. Translate the textual components of an enthymeme (explicit premise, claim, and implicit premises) into a formal logical argument.
2. Generate the necessary logical formulas to decode the argument and prove logical entailment.

2. Methodology: A Neuro-Symbolic Pipeline

The authors propose a five-component neuro-symbolic pipeline that bridges NLP and symbolic logic to decode enthymemes. The pipeline transforms natural language into logical formulas, applies "relaxation" techniques to handle semantic similarity, and uses automated reasoning to determine entailment.

Core Components:

1. Implicit Premise Generation (LLM):

   • Uses a Large Language Model (DeepSeek v3.2) to generate intermediate implicit premises based on the explicit premise and the claim.
   • The system supports multi-step reasoning, generating 1, 2, or 3 steps of intermediate premises to bridge the gap between the premise and the claim.
   • It generates both "helpful" (logically valid) and "unhelpful" (contradictory or neutral) premises for evaluation.

2. Text-to-AMR Parsing:

   • Converts natural language sentences (premises, claims, and generated implicit premises) into Abstract Meaning Representation (AMR) graphs using the IBM Transition AMR parser.
   • AMR represents semantics as rooted, labeled, directed acyclic graphs (DAGs), capturing semantic roles (e.g., arg0, arg1) and negation (:polarity).

3. AMR-to-Propositional Logic Translation:

   • Translates AMR graphs into propositional logic formulas using an extended version of the Bos algorithm.
   • Existentially quantified variables in First-Order Logic are grounded using Skolem constants, converting the logic into a propositional format (e.g., arg0(want, boy)).

4. Relaxation via Neuro-Symbolic Matching:

   • To handle the fact that natural language concepts are rarely identical but often semantically similar, the pipeline introduces two "relaxation" mechanisms:
     • Neuro-Matching ($\simeq$): Uses sentence embeddings (BAAI bge-small-en-v1.5) to map semantically similar atoms (e.g., "walking" and "moving") to the same propositional variable.
     • Neuro-Contradiction ($\perp$): Uses a Natural Language Inference (NLI) model (DeBERTa) to detect contradictions between atoms (e.g., "walking" vs. "sleeping"), mapping them to complementary literals (e.g., $x$ and $\neg x$).
   • These relations allow the system to rewrite AMR formulas into abstract formulas where semantic nuances are managed via thresholds ($\tau_m$ for matching, $\tau_c$ for contradiction).

5. Automated Reasoning (PySAT):

   • The abstract formulas are converted to Conjunctive Normal Form (CNF) using SymPy.
   • PySAT (a SAT solver) is used to check for consistency.
   • Entailment Check: To prove $\phi \vdash \psi$, the system checks if $\phi \land \neg \psi$ is inconsistent.
   • Contradiction Check: To prove $\phi \vdash \neg \psi$, the system checks if $\phi \land \psi$ is inconsistent.

3. Key Contributions

• End-to-End Pipeline: The first system to systematically translate free-text enthymemes into logical arguments, generate missing premises, and verify entailment without requiring a pre-built logical knowledge base.
• Neuro-Symbolic Relaxation: Introduces a novel method to relax strict propositional logic constraints by using embeddings and NLI models to identify semantic equivalence and contradiction, making logical reasoning more robust for natural language.
• Multi-Step Reasoning: Demonstrates that generating multi-step intermediate premises (1, 2, or 3 steps) significantly improves the ability to decode complex arguments compared to single-step or dataset-provided premises.
• Explainability: The pipeline produces structured argument graphs (as shown in Figure 4 of the paper) that visualize which implicit premises and relaxation relations (neuro-matching/contradiction) were used to derive the conclusion.

4. Results and Evaluation

The pipeline was evaluated on two datasets: ARCT (Argument Reasoning Comprehension Task) and ANLI (Abductive Natural Language Inference).

• Performance Metrics: The system was evaluated on Precision, Recall, F1-score, and Accuracy for classifying entailment vs. non-entailment.
• Impact of Multi-Step Premises:
  • Accuracy improved consistently as the number of reasoning steps increased.
  • 3-step premises yielded the highest performance (e.g., 0.75 F1 on ANLI, 0.74 on ARCT for specific classes).
  • LLM-generated multi-step premises outperformed the "original" single-step premises found in the datasets.
• Threshold Sensitivity:
  • Neuro-Matching Threshold ($\tau_m$): Optimal performance was found at moderate values (0.55–0.65).
  • Neuro-Contradiction Threshold ($\tau_c$): Lower values (e.g., 80) increased sensitivity to contradictions, improving the classification of non-entailment cases. Higher values (100) made the system too conservative.
• Dataset Differences: The ANLI dataset showed greater sensitivity to parameter tuning and higher overall accuracy gains from multi-step reasoning compared to ARCT, likely due to the inherent ambiguity in abductive reasoning tasks.

5. Significance

This work addresses a critical bottleneck in computational argumentation: the gap between unstructured text and formal logic. By integrating LLMs for premise generation with symbolic solvers for rigorous entailment checking, the authors provide a framework that:

1. Democratizes Logical Reasoning: Allows logical analysis of arguments without manually curating knowledge bases.
2. Enhances Interpretability: Unlike "black box" NLP models, this pipeline explicitly shows the logical steps and the semantic relaxations required to reach a conclusion.
3. Bridges AI Subfields: It effectively combines the generative capabilities of LLMs with the rigor of symbolic AI (neuro-symbolic AI), offering a pathway for more reliable and explainable AI in legal, scientific, and debate contexts.