2 Preliminaries and baseline setting

This section introduces a formal abstraction of LLM-based extraction pipelines, including existing approaches such as LLMASP. While inspired by prior work, this abstraction is new and will serve as the foundation for the logic-guided framework introduced in Section 3. The presentation is intentionally minimal and focuses only on concepts required to formalize logic-guided extraction.

Text, predicates, and facts. Let $T$ denote a finite unstructured text document, and $\mathscr{T}$ be the domain of text documents. Let $\mathscr{P}$ be a fixed finite set of predicates, each with a fixed arity. A ground fact is an atom of the form $p(c_1,\dots ,c_k)$ , where $p \in \mathscr{P}$ has arity $k \geq 0$ and each $c_i$ is a constant from a fixed finite domain of constants. Let $\mathscr{F}_p$ denote the set of all ground facts over predicate $p$ , for all $p \in \mathscr{P}$ , and $\mathscr{F}$ be the set of all ground facts, that is $\mathscr{F} = \bigcup _{p \in \mathscr{P}}{\mathscr{F}_p}$ . A database $D$ is a finite set of ground facts, that is, $D \subseteq \mathscr{F}$ . Let $\mathscr{D}$ denote the domain of databases, defined as $2^{\mathscr{F}}$ . In the following, we assume databases grow monotonically during an extraction process, that is, along a finite sequence $D_0 \subseteq \dots \subseteq D_n$ .

Queries. We consider boolean conjunctive queries over databases. A conjunctive query $q$ is a conjunction of (possibly negated) atoms whose variables are implicitly existentially quantified. Given a database $D$ , we say that $q$ is true in $D$ , written $D \models q$ , if there exists a substitution $\sigma$ mapping the variables of $q$ to constants such that (i) for every positive atom $a$ in $q$ , $a\sigma \in D$ , and (ii) for every negated atom $\mathit{not}\ a$ in $q$ , $a\sigma \notin D$ . A query $q$ is said to be monotone if for all databases $D \subseteq D'$ , $D \models q$ implies $D' \models q$ . In our setting, monotone queries are exactly those that do not contain negated atoms. In later sections, monotone queries will be exploited to optimize logic-based control checks via caching.

Logic programs. Let $\mathscr{LP}$ denote the set of logic programs over predicates in $\mathscr{P}$ . Specifically, we consider normal logic programs under the stable model semantics. A normal rule is an expression “head if body” of the form

\begin{equation*} a \leftarrow b_1,\dots ,b_m,\ \mathit{not}\ c_1,\dots ,\mathit{not}\ c_n, \end{equation*}

where $a$ , $b_i$ , and $c_j$ are atoms. A normal program $\Pi$ is a finite set of normal rules over predicates in $\mathscr{P}$ . Programs are interpreted under their standard ground instantiation with respect to the fixed finite domain of constants. Given a ground program $\Pi$ and a set of ground atoms $I$ , the Gelfond–Lifschitz reduct $\Pi ^I$ is obtained by removing all rules whose body contains a negative literal $\mathit{not}\ c$ with $c \in I$ , and by deleting all remaining negative literals from the bodies of the remaining rules. A set of atoms $I$ is a stable model (or answer set) of $\Pi$ if $I$ is the least model of the reduct $\Pi ^I$ . In the intended extraction setting, the programs are constructed so that $\Pi \cup D$ has a unique intended answer set. We denote it by $\mathit{Ans}_{\Pi }(D)$ .

Extraction oracle. We abstract the behavior of a LLM by means of an extraction oracle. Let $\mathscr{P}_E = \{p_1,\dots ,p_n\} \subseteq \mathscr{P}$ be a finite set of target predicates, that is predicates whose facts are to be extracted from text. When needed, we assume that the set of target predicates $\mathscr{P}_E$ is equipped with a fixed ordering. Formally, an extraction oracle is a function

\begin{align*} \begin{array}{rcl} \mathscr{O} : \mathscr{T} \times \mathscr{P}_E &{}\rightarrow {}& \mathscr{D}\\ (T,p) &{}\mapsto {}& D \end{array} \end{align*}

such that $D \subseteq \mathscr{F}_p$ . Intuitively, $\mathscr{O}(T,p)$ returns a (possibly empty) set of candidate facts for predicate $p$ extracted from the input text $T$ . The oracle may be incomplete or return spurious facts, and no assumptions are made regarding determinism, completeness, or monotonicity of its behavior. Since at most one oracle call is performed per target predicate, the length of the extraction sequence is bounded by $|\mathscr{P}_E|$ .

Prompt transformations. We model prompt construction abstractly as text transformations. Let $\Gamma : \mathscr{T} \to \mathscr{T}$ be a global transformation encoding macro-task or domain-level instructions, and let $\gamma _p : \mathscr{T} \to \mathscr{T}$ be predicate-specific transformation encoding instructions for extracting predicate $p \in \mathscr{P}_E$ . The extraction oracle is always applied to transformed texts of the form $\gamma _p(\Gamma (T))$ , that is, when we write $\mathscr{O}(T,p)$ we actually mean $\mathscr{O}(\gamma _p(\Gamma (T)),p)$ . Stated differently, prompt transformations are modeled as text-to-text functions applied to the input text before oracle invocation; for clarity of presentation, they are omitted from the notation.

Example 2 (Running example). Let $\Gamma$ be the macro-task function mapping a text $\underline {t}$ to

Let $\gamma _{\mathtt {in\_layer/2}}$ be the transformation associated with in_layer/2, mapping a text $\underline {t}$ to

Let $T$ be the following unstructured text document:

So, if we call $\mathscr{O}(T,p)$ , we are actually calling $\mathscr{O}(T',p)$ , where $T' = \gamma _p(\Gamma (T))$ is

The expected output are facts in_layer(0,n1), in_layer(0,n2), in_layer(0,n3), in_layer(2,n7), and in_layer(2,n9), while facts like in_layer(2,n8), and in_layer(1,n5) must not be produced in output as they are not explicitly mentioned in $T$ . Specifically, we expect that the extraction process terminates reporting only facts that are actually present in the given input, avoiding any speculative interpolation of missing data.

Baseline extraction pipeline (LLMASP). As baseline, we consider a predicate-wise extraction pipeline, as exemplified by LLMASP-style approaches presented by Alviano et al. (Reference Alviano, Reiners and Faber1925). Given a fixed set of target predicates $\mathscr{P}_E$ , we model the baseline extraction pipeline as a function

\begin{align*} \begin{array}{rcl} \mathsf{LLMASP} : \mathscr{T} \times \mathscr{D} \times \mathscr{LP} &{}\rightarrow {}& \mathscr{D} \\ (T, D_0, \Pi ) &{}\mapsto {}& \mathit{Ans}_\Pi (D_0 \cup \bigcup _{p \in \mathscr{P}_E}{\mathscr{O}(T,p)}) \end{array} \end{align*}

where $\mathsf{LLMASP}(T, D_0, \Pi )$ denotes the database produced by the baseline pipeline on input text $T$ , program $\Pi$ and initial database $D_0$ . Operationally, the baseline invokes the extraction oracle independently for each target predicate $p \in \mathscr{P}_E$ on the (transformed) input text, collects all the extracted facts together with $D_0$ into a database $D' = D_0 \cup \bigcup _{p \in \mathscr{P}_E}{\mathscr{O}(T,p)}$ , and then applies ASP reasoning once using program $\Pi$ , yielding the final database $\mathit{Ans}_\Pi (D')$ . Note that, in this baseline setting, logical reasoning is applied only after the extraction phase and does not influence which target predicates are selected for extraction. This formalization will allow us to precisely compare the baseline with the logic-guided extraction framework introduced next.

Example 3 (Continuing Example 2). Let $\mathscr{P}_E$ be $\{\texttt{in}_{\texttt{layer/2}}, \texttt {layer}_{\texttt{size/2}}, \texttt {edge/2}\}$ , $\mathscr{O}(T,\texttt {layer}_{\texttt{size/2}})$ be $\{\texttt {layer}_{\texttt{size(0,3)}},$ $\texttt {layer}_{\texttt{size(1,3)}}, \texttt {layer}_{\texttt{size(2,3)}}\}$ and $\mathscr{O}(T,\texttt {edge/2})$ be $\{\texttt {edge(n1,n9)}, \texttt {edge(n4,n2)},$ $\texttt {edge(n4,n8)}\}$ . Let $\Pi$ be the following program:

where $r_1$ computes the symmetric closure of edge/2 (the graph is undirected), and $r_2$ detects inconsistencies or missing data in the input text. $\mathsf{LLMASP}(T,\emptyset ,\Pi )$ returns a database including warning(unmatched_layer_size, (1,3,0)) and warning(unmatched_layer_size, (2,3,2)). In an interactive setting, the derived warning facts may serve as explanations of inconsistencies or missing data, enabling the system to ask the user for clarification or further details.

3 Logic-guided extraction framework

In the baseline pipeline introduced in Section 2, extraction and reasoning are strictly separated: all target predicates are extracted independently by the oracle, and logical reasoning is applied only once as a post-processing step. While this approach is simple and effective, it does not exploit logical knowledge during the extraction process itself.

In this section, we introduce a logic-guided extraction framework in which logical reasoning actively controls the extraction process. The key idea is to interleave oracle calls with logic-based checks over the current database, allowing extraction decisions to depend on facts already obtained and on their logical consequences. As a result, oracle calls for certain target predicates can be safely skipped without affecting the final extracted information.

The framework presented here generalizes the baseline pipeline and subsumes it as a special case. It provides a formal basis for reducing the number of oracle invocations while preserving the extracted facts under suitable assumptions, and it enables additional optimizations such as caching of logic-based checks.

3.3 Logic-guided extraction semantics

We now define the semantics of logic-guided extraction using the guard-based admissibility conditions introduced in Section 3.2. Extraction proceeds over a fixed ordering $\mathscr{P}_E = \langle p_1,\dots ,p_n \rangle$ of target predicates. Each predicate $p_i$ is associated with a logic program $\Pi _{p_i}$ , which is applied after processing $p_i$ . We collectively refer to the ordering $\mathscr{P}_E$ , the guards $\{\mathscr{G}_{p_i}\}_{i=1}^n$ , and the programs $\{\Pi _{p_i}\}_{i=1}^n$ as a logic-guided extraction configuration. Let $\mathscr{C}$ denote the domain of all such configurations, and let $C \in \mathscr{C}$ be a fixed configuration.

Incremental database construction. The logic-guided extraction process constructs a sequence of databases $D_0 \subseteq D_1 \subseteq \dots \subseteq D_n$ , where $D_0$ is the initial database. For each $i \in \{1,\dots ,n\}$ , the database $D_i$ is obtained from $D_{i-1}$ by processing predicate $p_i$ according to its admissibility in $D_{i-1}$ . If predicate $p_i$ is admissible in $D_{i-1}$ , then the extraction oracle is invoked for $p_i$ , the extracted facts are added to the current database, and logical reasoning is applied using program $\Pi _{p_i}$ . If predicate $p_i$ is not admissible in $D_{i-1}$ , the oracle invocation is skipped and no logical reasoning is applied. Formally,

(1) \begin{align} D_i = \begin{cases} \mathit{Ans}_{\Pi _{p_i}}(D_{i-1} \cup \mathscr{O}(T,p_i)) & \text{if } D_{i-1} \models g \text{ for all } g \in \mathscr{G}_{p_i},\\ D_{i-1} & \text{otherwise.} \end{cases} \end{align}

Logic-guided extraction function. The logic-guided extraction semantics defined above induces a function

\begin{align*} \begin{array}{rcl} \mathsf{LGX} : \mathscr{T} \times \mathscr{D} \times \mathscr{C} &{}\rightarrow {}& \mathscr{D} \\ (T,D_0,C) &{}\mapsto {}& D_n \end{array} \end{align*}

which maps an input text $T$ , an initial database $D_0$ , and a configuration $C \in \mathscr{C}$ to the final database $D_n$ produced according to the semantics defined above.

Example 4 (Continuing example 3). Let $g$ be the guard layer_size(_,_), $g'$ be not warning(_,_), and $C$ be the configuration

\begin{align*} \left ( \langle {\texttt {layer}_{\texttt{size/2}}, \texttt {in}_{\texttt{layer/2}}, \texttt {edge/2}}\rangle , \langle { \emptyset , \{g\}, \{g'\} }\rangle , \langle { \emptyset , \{r_2\}, \{r_1\} }\rangle \right ) \end{align*}

The target predicates are ordered so that in_layer/2 is extracted only if some layer information has been found, as enforced by the guard $g$ . Moreover, the program $\Pi$ is split so that warnings about unmatched layer sizes (rule $r_2$ ) are derived immediately after extracting in_layer/2. If such warnings arise, the guard $g'$ fails, thereby preventing the extraction of edge/2 at later stages.

Baseline as a special case. In the proposed framework, a logic program can be seen as a degenerate logic-guided configuration in which no admissibility constraints are imposed and all logical reasoning is deferred to the final step. From this perspective, the baseline extraction pipeline of Section 2 is recovered as a special case of the above semantics. Specifically, for an arbitrary ordering $\mathscr{P}_E = \langle p_1,\dots ,p_n \rangle$ , we associate an empty set of guards to every predicate, that is, $\mathscr{G}_{p_i} = \emptyset$ for all $i$ . As a consequence, every predicate is admissible for extraction and the oracle is invoked for each $p_i$ . Moreover, we associate the empty program with all predicates except the last one. Formally, we set $\Pi _{p_i} = \emptyset$ for all $i \lt n$ and $\Pi _{p_n} = \Pi$ , where $\Pi$ is the baseline logic program. With this choice, no logical reasoning is applied during extraction. All reasoning is deferred to the processing of the last predicate $p_n$ . In this baseline setting, the order of predicates in $\mathscr{P}_E$ does not affect the final result. Accordingly, the input expected by $\mathsf{LGX}$ coincides exactly with the program parameter of the $\mathsf{LLMASP}$ function defined in Section 2.

3.4 Baseline equivalence

We now establish that the logic-guided extraction framework is equivalent to the baseline extraction pipeline under a degenerate configuration and a natural assumption on the extraction oracle.

Oracle assumption. We assume that the extraction oracle is guard-respecting, in the following sense. Let $p \in \mathscr{P}_E$ be a target predicate and let $D$ be a database. If $D \not \models g$ for some guard $g \in \mathscr{G}_p$ , then $\mathscr{O}(T,p) = \emptyset$ . Intuitively, when the admissibility conditions for a predicate are not satisfied, invoking the oracle for that predicate would not produce any extracted facts.

Theorem 1 (Equivalence theorem). Let $T \in \mathscr{T}$ be an input text and let $D_0 \in \mathscr{D}$ be an initial database. Let $\Pi$ be a logic program, seen as a degenerate logic-guided configuration as described in Section 3.3. Let $\mathsf{LGX}(T,D_0,\Pi )$ denote the result of logic-guided extraction under this configuration, and let $\mathsf{LLMASP}(T,D_0,\Pi )$ denote the result of the baseline extraction pipeline. Under the oracle assumption above, it holds that $\mathsf{LGX}(T,D_0,\Pi ) = \mathsf{LLMASP}(T,D_0,\Pi )$ .

Proof (sketch). Let $D_0 \subseteq \dots \subseteq D_n$ be the sequence of databases produced by $\mathsf{LGX}(T,D_0,\Pi )$ . For all $i \in \{1,\ldots ,n\}$ , we have $\mathscr{G}_{p_i} = \emptyset$ by assumption. Hence, $D_{i-1} \models g$ for all $g \in \mathscr{G}_{p_i}$ holds vacuously, and the update rule (1) reduces to $D_i = \mathit{Ans}_{\Pi _{p_i}}(D_{i-1} \cup \mathscr{O}(T,p_i))$ .

By construction of the degenerate configuration, $\Pi _{p_i} = \emptyset$ for all $i \lt n$ , and $\Pi _{p_n} = \Pi$ . Moreover, $\mathit{Ans}_\emptyset (D) = D$ for any database $D$ . Therefore, for all $i \in \{1,\ldots ,n\}$ ,

\begin{equation*} D_i = \begin{cases} D_{i-1} \cup \mathscr{O}(T,p_i) & \text{if } i \lt n,\\ \mathit{Ans}_{\Pi }(D_{n-1} \cup \mathscr{O}(T,p_n)) & \text{if } i = n. \end{cases} \end{equation*}

Unfolding the construction of $D_n$ , we obtain

\begin{equation*} \mathsf{LGX}(T,D_0,\Pi ) = D_n = \mathit{Ans}_{\Pi }\!\left (D_0 \cup \bigcup _{i=1}^{n} \mathscr{O}(T,p_i)\right ). \end{equation*}

By definition of $\mathsf{LLMASP}$ , the right-hand side coincides with $\mathsf{LLMASP}(T,D_0,\Pi )$ .

4 Implementation

This section presents a concrete realization of the logic-guided extraction framework defined in Section 3, given in Algorithm 1, and shows how its declarative semantics can be operationalized in practice. Implementation choices such as guard caching affect only efficiency and do not alter the formal semantics of the framework.

Algorithm 1

LGX-Exec(T, D ₀,C): Logic-guided extraction with guard caching

Guard evaluation. For a predicate $p_i$ , admissibility is determined by evaluating the guards in $\mathscr{G}_{p_i}$ against the current database $D$ . A guard $g$ is evaluated by checking whether a fresh atom $q$ is derivable from the program $\{q \leftarrow g\}$ together with the facts in $D$ , that is, whether $q \in \mathit{Ans}_{\{ q \leftarrow g \}}(D)$ . Guard evaluation conceptually corresponds to the conjunction of the guards in $\mathscr{G}_{p_i}$ . As soon as one guard is found to be false, the predicate $p_i$ is deemed not admissible and no further guard evaluations are required. If all guards hold, $p_i$ is admissible, the extraction oracle is invoked, and the facts returned by the oracle are combined with the current database and processed by the associated logic program $\Pi _{p_i}$ .

Guard caches. In what follows, we use $\top$ and $\bot$ to denote the Boolean outcomes true and false. To optimize guard evaluation, the algorithm maintains a family of cache sets $\mathscr{K}^{\,\,\tau }_{\mu }$ , where $\tau \in \{\top ,\bot \}$ denotes the truth value of a guard and $\mu \in \{m,n\}$ denotes whether the guard is monotone or non-monotone. A guard $g$ belongs to $\mathscr{K}^{\,\,\tau }_{\mu }$ if it has previously been evaluated with truth value $\tau$ and $\mathit{mono}(g)=\mu$ , where $\mathit{mono}$ determines the monotonicity of guards. Cached results are reused whenever possible. When the database is extended, cached results for non-monotone guards and cached negative results for monotone guards are invalidated, while cached positive results for monotone guards are preserved. This policy is sound by Theorem 2 and affects only the number of guard evaluations performed, without altering admissibility decisions or the final database produced.

5 Experimental evaluation

In this section, we empirically evaluate the $\mathsf{LGX}$ framework to assess its effectiveness in reducing LLM oracle calls, its impact on extraction quality, and the efficiency of the proposed caching strategies. Source files and datasets are available online at https://github.com/Xiro28/LGX.

Implementation and setup. From an implementation standpoint, we observe how the two cache sets $\mathscr{K}^{\,\bot} _m$ and $\mathscr{K}^{\,\bot} _n$ can be safely combined, since entries of both sets require re-evaluation once the database has changed. Our framework is implemented using clingo 5.8 by Gebser et al. (Reference Gebser, Kaminski and Schaub1911) as the underlying ASP solver, and Meta Llama 3.1 proposed by Meta (1924) as the extraction oracle, deployed in two configurations: a lightweight version (8B, hereafter referred to as Small) and a medium-capacity version (70B, referred to as Medium). Additionally, we performed robustness tests with a third high-capacity configuration based on GPT-OSS presented by OpenAI (1925), denoting its 120B version as Large, to evaluate the consistency of the framework’s performance across model architectures.

To ensure a fair and rigorous comparison, we simulated the $\mathsf{LLMASP}$ baseline using the $\mathsf{LGX}$ engine itself, adopting the degenerate configuration described in Section 3.4. This approach eliminates potential implementation biases, ensuring that performance deltas are solely attributable to the logic-guided strategy. Furthermore, we minimized stochastic variance by setting the LLM sampling temperature to $0$ and employing a persistent cache for oracle calls. This guarantees that identical queries yield the same candidate facts across different system runs, effectively isolating the impact of the logic-guided control flow on both extraction efficiency and quality.

Benchmarks. Our evaluation relies on two primary benchmarks designed to assess different aspects of the logic-guided extraction.

Graph benchmark (G). Based on our running example of layered graphs, this benchmark compares LGX against the LLMASP baseline under two guard enforcement strategies (see Table 1): (i) None, representing a naïve, blind extraction; and (ii) A posteriori, where invalid results are pruned post-hoc using manually injected constraints.

Logic puzzle benchmark (LNRS). Adapted from the work by Alviano et al. (Reference Alviano, Grillo, Lo Scudo and Reiners1925), this dataset aggregates four ASP domains (Labyrinth, Nomystery, Ricochet Robots and Sokoban) to evaluate mixed-domain handling. In this setting, an initial domain-identifier extraction acts as a hierarchical guard, restricting all subsequent oracle calls to the specific puzzle schema and preventing cross-domain noise.

Table 1.

Experimental results on Graph (G) and Logic Puzzle (LNRS) benchmarks. We report the number of Oracle interactions ( $\mathscr{O}$ Calls), the enforcement strategy, and accuracy metrics (F1-Score, Perfect Rate)

Performance and efficiency analysis. Table 1 summarizes the experimental results on the Graph (G) and Logic Puzzle (LNRS) benchmarks. The empirical data supports three key observations regarding the impact of $\mathsf{LGX}$ :

• • Drastic reduction in traffic. $\mathsf{LGX}$ significantly lowers the number of interactions with the oracle compared to the baseline. In the LNRS benchmark, calls are reduced by approximately 72% (dropping from 3072 to 864 calls with the medium oracle). This confirms that the logic-guided pruning effectively identifies and discards inconsistent branches before expensive queries are made.

• • Accuracy equivalence. Consistent with Theorem 1, the accuracy of $\mathsf{LGX}$ (enforcement by design) is identical to the a posteriori baseline. This empirically verifies that our pruning strategy is sound: it optimizes efficiency without compromising the quality of the solution.

• • Scalability with complexity. The efficiency gap widens significantly as the logical structure deepens. While the reduction is moderate for the structurally simpler G benchmark ( $\sim$ 15–20%), it becomes substantial for the hierarchically structured LNRS benchmark. This confirms that $\mathsf{LGX}$ excels in rich domains, where guard dependencies enable aggressive pruning of oracle calls.

Quality analysis (Benchmark G). Naïve extraction generates spurious facts, such as invalid layers not explicitly mentioned in the input text, or facts that are not expected to be extracted due to failing guards. These structural inconsistencies severely impact F1-score and Perfect Rate. While $\mathsf{LLMASP}$ can recover quality via a posteriori filtering, $\mathsf{LGX}$ ensures this consistency by design. This allows $\mathsf{LGX}$ to achieve optimal quality with strictly fewer oracle calls (Table 1), unlike the fixed-cost baseline.

Efficiency analysis (Benchmark LNRS). Efficiency is critical in the mixed-domain LNRS benchmark. While the baseline indiscriminately queries all predicates, incurring high costs, $\mathsf{LGX}$ matches the optimal accuracy of the a posteriori configuration at a fraction of the expense. By proactively pruning irrelevant queries rather than filtering results post-hoc, $\mathsf{LGX}$ avoids the prohibitive overhead of the standard pipeline.

ASP solver overhead. Our caching strategy significantly reduces internal reasoning costs. In LNRS, shared guards allow $\mathsf{LGX}$ to avoid between 61.4% and 82.6% of redundant ASP solver calls. Crucially, even where caching is less effective (Benchmark G), the latency introduced by guard checks is negligible compared to the massive runtime savings achieved by reducing oracle interactions.

6 Related work

Existing work on combining LLMs with logic-based reasoning can be categorized according to the role assigned to the symbolic component. In some approaches, logic is the target representation generated from text; in others, it is used as a validation layer, or as part of a probabilistic neuro-symbolic semantics. We discuss these lines of work with emphasis on their relation to extraction from natural language and to the use of ASP as a reasoning component.

Logic as a target language. A first class of approaches uses natural-language processing, and more recently LLMs, to construct a symbolic representation that is then given to a logic-based solver. This view extends earlier work in which natural-language content was encoded directly in ASP or related declarative languages. For example, Pendharkar et al. (Reference Pendharkar, Basu, Shakerin and Gupta1922) represent English passages through a Neo-Davidsonian formalism and use common-sense knowledge from WordNet, a lexical database presented by Miller (Reference Miller1995), to answer questions over the resulting program. With the advent of LLMs, part of the symbolic encoding can be delegated to neural generation. Ishay et al. (Reference Ishay, Yang and Lee1923) introduce a Generate–Define–Test methodology to obtain entities, relations, and rules from text; Ishay and Lee (Reference Ishay and Lee1925) extend this direction to action languages for temporal and causal reasoning. Similarly, the STAR framework of Rajasekharan et al. (Reference Rajasekharan, Zeng, Padalkar and Gupta1923) translates natural-language knowledge into a representation processed by s(CASP), supporting goal-directed and explainable derivations. These approaches differ from ours because the LLM is primarily used to construct the symbolic theory itself. In our setting, the symbolic schema and the control knowledge are fixed by the framework, while the LLM is used to produce candidate facts.

Logic-based extraction with fixed schemas. A second line of work assumes a fixed relational or logical schema and uses the LLM to populate it from natural language. The [LLM]+ASP framework of Yang et al. (Reference Yang, Ishay and Lee1923) and LLMASP by Alviano et al. (Reference Alviano, Grillo, Lo Scudo and Reiners1925) are representative of this direction and motivate the predicate-wise abstraction adopted earlier in the paper. Related ideas also appear in systems such as AutoCompanion by Zeng et al. (Reference Zeng, Rajasekharan, Basu, Wang, Arias and Gupta1924), where s(CASP) is used as a symbolic component in a dialogue setting. These approaches provide an important reference point for our work because they separate extraction from reasoning through a fixed schema. The distinction is that, in our framework, part of the symbolic reasoning is moved from post-processing to extraction control: logical conditions are evaluated during the construction of the database and can affect which extraction requests are issued.

Probabilistic neuro-symbolic reasoning. A distinct family of neuro-symbolic systems integrates neural predictions directly into a probabilistic logical semantics. DeepProbLog by Manhaeve et al. (Reference Manhaeve, Dumancic, Kimmig, Demeester and Raedt1918) extends probabilistic logic programming with neural predicates, and NeurASP by Yang et al. (Reference Yang, Ishay and Lee1920) combines ASP with probability distributions associated with atoms generated by neural classifiers. These frameworks provide a principled account of uncertain neural outputs and support forms of learning or probabilistic inference. Our setting is different in two respects. First, the LLM is treated as a pre-trained black-box oracle rather than as a trainable neural component integrated into the semantics. Second, extracted atoms are handled as crisp candidate facts, and the role of ASP is to derive consequences, check consistency, and control admissibility rather than to assign or combine probabilities.

Post-hoc validation and refinement. Several approaches use symbolic reasoning, execution feedback, or self-reflective procedures only after a neural model has generated an output. For instance, Eiter et al. (Reference Eiter, Geibinger, Higuera and Oetsch1923) use ASP to compute contrastive explanations for visual question-answering results. In the LLM literature, Self-Refine by Madaan et al. (Reference Madaan, Tandon, Gupta, Hallinan, Gao, Wiegreffe, Alon, Dziri, Prabhumoye, Yang, Gupta, Majumder, Hermann, Welleck, Yazdanbakhsh and Clark1923) and Reflexion by Shinn et al. (Reference Shinn, Cassano, Gopinath, Narasimhan and Yao1923) introduce iterative feedback loops in which generated answers are critiqued and revised. These methods can improve output quality by detecting or correcting problematic outputs after generation. The framework proposed here addresses a complementary problem: it uses logic before selected extraction calls are made, so that some irrelevant or inadmissible queries are never issued to the oracle.