Licensing Oracle for Truth-Constrained LMs

• Licensing Oracle is a deterministic module that enforces truth constraints by validating LM-generated claims against an RDF knowledge base using formal entailment and SHACL rules.
• It integrates with language model pipelines via claim extraction, context retrieval, and a validation gate that selectively allows only provable, schema-compliant outputs.
• Empirical evaluations demonstrate high accuracy, perfect abstention precision, and zero hallucinations, making it a robust solution for factual consistency in critical domains.

A Licensing Oracle is an architectural module for LMs that enforces truth constraints on generated outputs by formally validating factual claims against a structured knowledge graph. Unlike statistical or data-driven approaches (such as scaling, fine-tuning for factuality, or retrieval-augmented generation), the Licensing Oracle interposes a deterministic “validation gate” between the generative model and its output, ensuring that only claims which are provably entailed by the knowledge base and satisfy domain schema constraints are allowed to be emitted. This mechanism provides epistemic guarantees—namely, perfect abstention precision and zero hallucinations—on any information domain representable as an RDF graph with formal SHACL constraints (Emanuilov et al., 8 Nov 2025).

1. Architectural Components and Workflow

The Licensing Oracle is architecturally integrated into LM inference as a middleware module that intercepts the generative process at the level of claims emission. The pipeline operates as follows:

1. Contextual Retrieval (Optional): A retriever may first fetch a relevant subgraph $\mathcal{G} \subset \mathcal{K}$ for grounding, where $\mathcal{K}$ is the global RDF knowledge graph.
2. LLM Generation: The LM generates a candidate sequence of tokens in response to a user prompt, optionally conditioned on the retrieved subgraph.
3. Claim Extraction: An event-driven extractor monitors the generation stream. Upon parsing a candidate factual statement, it emits a semantic triple $c = (s,p,o)$ (subject, predicate, object) representing the claim.
4. Oracle Validation: For each extracted $c$, the Licensing Oracle applies a Boolean validation function $V(c, \mathcal{K})$. This consists of two checks:
   • Entailment: $c$ must be present or semantically entailed in $\mathcal{K}$.
   • SHACL Conformity: $c$ must not violate any SHACL constraint (i.e., must be structurally and typologically valid).
5. Decision Mechanism:
   • If $V(c, \mathcal{K}) = 1$ (licensed), output proceeds unimpeded.
   • If $V(c, \mathcal{K}) = 0$ (unlicensed), emission is interrupted, and the sequence is replaced with an explicit abstention (e.g., "I don’t know").
6. Provenance Logging: Each licensing decision is accompanied by logging of supporting triples and violated/validated SHACL shapes for auditability.

This architecture transforms the probabilistic LM into a truth-constrained generator that can abstain where required and never emits unlicensed, hallucinated claims.

2. Formal Validation Logic and Acceptance Criterion

Let $\mathcal{C}$ be the space of all possible candidate claims and $\mathcal{K}$ the RDF knowledge graph. The Licensing Oracle's core is the validation function

$$V\bigl(c, \mathcal{K}\bigr)\;=\; \begin{cases} 1, & \text{if } c\in\mathrm{Entail}(\mathcal{K}) \;\wedge\; \neg\mathrm{violates}_{\Delta}(c),\ 0, & \text{otherwise.} \end{cases}$$

where $\Delta$ denotes the set of SHACL constraints. A claim is permitted if and only if it is entailed by the current knowledge graph and passes all schema validations.

The acceptance criterion is thus:

$V(c,\mathcal{K}) = 1 \iff \text{the claim %%%%13%%%% is formally licensed for emission}.$

If $V = 0$, the generation is compelled to abstain rather than output an unsupported or invalid claim, providing a deterministic guarantee of truth-constrained output.

3. Algorithmic Implementation

Pseudo-code for the inference-time loop integrating the Licensing Oracle is as follows:

def GENERATE_WITH_LICENSE(query, K, Delta): subgraph = RETRIEVE_SUBGRAPH(query, K) # optional RAG step tokens = LM.generate(query + subgraph) output = [] for t in range(len(tokens)): output.append(tokens[t]) claims = EXTRACT_CLAIMS(output) for c in claims: if V(c, K) == 0: return ABSTAIN_TOKEN, provenance(c, K, Delta) return CONCAT(output), provenance(output)

Realizations:

• The extractor may operate as an NER pipeline, mapping text to triples in real time.
• $V(c, \mathcal{K})$ encapsulates both SPARQL entailment checks and SHACL compliance.
• Provenance includes the supporting graph triples and SHACL shapes justifying each accept/reject.

This operational workflow converts the LM into a two-stage generator: unconstrained linguistic composition, tightly coupled with a downstream, non-probabilistic licensing filter.

4. Evaluation Metrics and Empirical Performance

Performance is measured using carefully defined metrics:

• Accuracy: Fraction of queries for which the model both answers and does so correctly.
• Abstention Precision (AP): Among all abstentions, the fraction corresponding to unanswerable (not entailed) questions. $AP = 1.0$ indicates no false negatives.
• False Answer Rate on Non-Entailed Claims (FAR$_{NE}$): Fraction of unanswerable questions for which the model erroneously tries to answer. $FAR_{NE} = 0.0$ indicates perfect suppression of hallucinations.
• Licensed Answer Accuracy (LA): Accuracy on entailed questions that are answered (should be 1.0 if facts are correctly matched).

Empirical results (U.S. rivers QA, 17,726 questions):

Method	Accuracy	AP	FAR$_{NE}$	LA
Baseline LLM	50.1%	n/a	n/a	n/a
Fine-tuned (recall)	8.5%	–	–	–
Fine-tuned (abstain)	8.6%	56.7%	large	–
RAG	89.5%	n/a	$>0$	–
Graph-RAG + Licensing	89.1%	1.0	0.0	1.0

These results establish that only the Oracle architecture achieves both high factual accuracy and provable elimination of hallucination errors (Emanuilov et al., 8 Nov 2025).

5. Theoretical Guarantees and Assumptions

The Licensing Oracle provides strong epistemic guarantees:

• No hallucinations: If $\mathcal{K}$ is sound and SHACL rules $\Delta$ are correct, $$\exists c \notin \mathrm{Entail}(\mathcal{K}) \lor \mathrm{violates}_\Delta(c) \implies c$$ is never generated.
• Perfect abstention: If $\mathcal{K}$ is incomplete, abstention is conservative (possible false negatives but no false positives).
• Robustness to incomplete graphs: The Oracle never emits false claims under graph incompleteness, only increases abstention.
• Formal correctness-by-construction: Licensing is reduced to a finite set of deterministic graph and SHACL queries.

Assumptions:

• $\mathcal{K}$ must be consistent and sufficiently complete for coverage.
• SHACL constraints encode all necessary domain invariants; inconsistency in $\mathcal{K}$ or mis-specified schema can invalidate the guarantee.
• Current implementation validates atomic triples; extension to multi-hop or compositional reasoning remains a future direction.

6. Comparison with Statistical and Retrieval Methods

Baseline LLMs without grounding frequently hallucinate, achieving only moderate accuracy (e.g., 50.1%) and lacking any abstention or error-detection capability. Data-driven approaches—e.g., factual recall or abstention fine-tuning—suffer from catastrophic forgetting and imprecise abstention (AP $\ll 1$). Retrieval-augmented generation, while improving factuality (accuracy ≈ 89.5%), can still emit hallucinations and cannot match the Oracle’s zero false answer rate.

By contrast, the Licensing Oracle, operating as an architectural insertion rather than a learned bias, eliminates the pathway for hallucinated statements. It is “necessary and sufficient” for stemming hallucinations in any domain with a structured knowledge base and formal schema constraints (Emanuilov et al., 8 Nov 2025). This suggests that architectural validation ought to be a required component for critical domains (medicine, science, law).

7. Generality, Applications, and Outlook

The Licensing Oracle framework extends to any domain representable as an RDF graph equipped with SHACL constraints. It is model-agnostic at the LM level and can be attached to any decoder. Application scenarios include:

• Medical QA from curated terminologies and linked datasets.
• Scientific reporting over knowledge graphs with ontologies.
• Regulatory and legal document automation, providing epistemic guarantees of correctness.
• Information extraction and dialogue agents in settings where hallucinations are unacceptable.

A plausible implication is that licensing—interpreted broadly as deterministic factual validation—constitutes the foundation for truth-constrained, epistemically grounded AI generation at scale.

Summary Table: Oracle vs. Baseline and RAG

Property	Baseline LM	RAG	Licensing Oracle
Factual Accuracy	50.1%	89.5%	89.1%
Hallucination Elimination	No	No	Yes (FAR$_{NE}$=0)
Abstention Precision	n/a	n/a	1.0
Provenance Logging	No	Partial	Full
Fails Safe on Unknowns	No	No	Yes

In summary, the Licensing Oracle enforces a deterministic, transparent barrier between generative fluency and factuality, yielding formal guarantees of truth-constrained output and perfect suppression of hallucinated claims in structured domains (Emanuilov et al., 8 Nov 2025).