Mind the Gap: Interpolants, Ontologies, and the Quiet Engineering of AI Reasoning

Deletion sounds simple until the system still knows the thing you deleted.

A company removes a sensitive supplier label from its knowledge graph. A hospital publishes a subset of a medical ontology without exposing internal diagnostic codes. A compliance team rewrites a rule base so external partners can query it without seeing the original vocabulary. Everyone nods. The data is “sanitized.” The schema is “simplified.” The private terms are gone.

Then the reasoning engine calmly reconstructs the missing relation from what remains.

That is the gap this paper is about: not the gap between raw data and AI output, but the gap between what a knowledge system says explicitly and what it still entails after you rewrite it. Jung, Koopmann, and Knorr’s chapter on interpolation in knowledge representation is not a flashy paper. It is better than that. It is a map of the quiet machinery needed when symbolic AI systems must forget, explain, modularize, define, summarize, or rewrite knowledge without changing the logical behavior that matters.¹

The central point is simple enough to state and difficult enough to engineer: interpolation is a way to rewrite knowledge through a restricted vocabulary while preserving selected consequences. The unpleasant detail, because logic enjoys ruining product roadmaps, is that such rewrites may not exist, may explode in size, or may depend sharply on the reasoning formalism.

The paper’s useful contribution is therefore not one trick. It is a taxonomy of where interpolation helps, where it breaks, and what engineering choices remain when the perfect object cannot be computed.

The useful distinction: Craig interpolants explain one entailment; uniform interpolants preserve a whole vocabulary

Interpolation has two main forms in the paper.

A Craig interpolant sits between a premise and a conclusion. If a knowledge base entails a claim, the interpolant uses only the shared vocabulary between the two sides and acts as a bridge: strong enough to follow from the premise, strong enough to imply the conclusion, but stripped of irrelevant symbols. In practice, this is useful for explanation. It answers: what part of the shared conceptual language makes this inference go through?

A uniform interpolant is more ambitious. Given a knowledge base and a target signature, it produces a new knowledge base using only that signature while preserving all consequences expressible in that signature. In practice, this is the formal version of forgetting. It answers: what can we say after removing selected symbols, while preserving everything the remaining vocabulary can still express?

That difference matters operationally.

The reader’s likely misconception is that interpolation is just a clever summarization method. It is not. A summary may drop details because they look unimportant. A uniform interpolant must preserve all relevant entailments over a chosen signature. That is a much stricter contract. The reward is semantic discipline. The price is complexity.

Uniform interpolation is controlled forgetting, not semantic amnesia

The paper begins with applications because that is where interpolation becomes legible. Uniform interpolation corresponds closely to forgetting: remove symbols from the language, but preserve the consequences over the remaining symbols.

That sounds like redaction. It is stricter.

Suppose an ontology contains internal terms such as Grad, PrivateDiagnosis, or SupplierRiskFlag. A naive redaction deletes rules mentioning those terms. But deleting rules can destroy consequences that should still remain. A uniform interpolant tries to keep the maximal information expressible without the removed terms.

This is why the paper connects uniform interpolation to information hiding, publication, ontology exchange, modularization, reuse, analysis, and summarization. The shared pattern is not “make the ontology shorter.” It is: change the visible vocabulary while preserving the right consequences.

For a business system, that changes how we should think about governance. The question is not merely:

Did we remove the sensitive field?

The better question is:

After removing the sensitive field, what can still be inferred using the remaining vocabulary?

That is a harder question and a more useful one. It is also why interpolation belongs in the engineering layer beneath AI governance dashboards. The dashboard can say “access restricted.” The reasoner still needs a formal guarantee about what remains inferable.

The first bad joke: the interpolant may not exist

The paper’s first serious warning is that uniform interpolants are not guaranteed to exist, even for simple description logic ontologies.

This is the part that prevents interpolation from becoming a cheerful product feature with a button labeled “forget.” In some cases, preserving exactly the remaining-language consequences would require an infinite or non-expressible object. The paper gives examples where no finite ontology in the target description logic can capture precisely the needed consequences.

The important business interpretation is not “therefore interpolation is useless.” That would be a lazy conclusion. The correct interpretation is that interpolation is a specification with failure modes.

A production system using ontology forgetting needs to know which contract it is offering:

This is the paper’s most practical lesson: the engineering question is often not “Can we compute the perfect interpolant?” It is “Which approximation preserves the consequence class our application actually uses?”

That is less glamorous than “AI reasoning made transparent.” It is also how real systems survive contact with budgets.

The second bad joke: when interpolants exist, they may be enormous

Existence is only the first gate. Size is the second.

For description logics such as $\mathcal{EL}$ and $\mathcal{ALC}$, the paper reports known results showing that uniform interpolant existence is ExpTime-complete for $\mathcal{EL}$ and 2ExpTime-complete for $\mathcal{ALC}$. Worse, even when a uniform interpolant exists, it may require triple-exponential size in the worst case.

This is not a minor implementation detail. It means that “preserve all consequences over this vocabulary” can demand an object far larger than the original ontology. The paper sketches why using counter-style constructions: a compact ontology can encode behavior whose signature-restricted consequences unfold into an enormous family of required inclusions.

For managers, the translation is blunt:

Logical compression and syntactic compression are different things.

An ontology can be small because it uses hidden symbols to encode structure compactly. Once those symbols are removed, the remaining language may need to spell out what the hidden machinery previously compressed. The interpolant can become larger because it is now carrying the semantic consequences without the original vocabulary.

That is the opposite of the usual “summarization” intuition. Forgetting a vocabulary can make the representation bigger. The knowledge base is not being summarized like a memo. It is being recompiled under vocabulary constraints.

Practical tools turn impossibility into controlled compromise

The paper does not stop at complexity. It reviews practical approaches for computing uniform interpolants in description logics, including tools such as Nui, Lethe, and Fame.

The methods vary, but the shared engineering pattern is symbol elimination. Tools try to remove concept or role names that should not appear in the final ontology while preserving the consequences that depend on them. Lethe, for example, combines resolution-style inference with Ackermann-style elimination. Fame relies on Ackermann-based methods. Other approaches use unfolding or resolution approximations.

The tool table in the paper is not an experimental comparison. It is better read as an implementation taxonomy:

The key detail is how these tools handle non-existence. They do not magically repeal the theorems. They choose a compromise: approximate to a bounded depth, extend the logic with greatest fixpoints, or introduce auxiliary concepts that simulate fixpoint behavior.

That is the pattern worth carrying into business architecture. A robust semantic governance pipeline should expose the compromise explicitly. “Exact,” “bounded,” “extended-language,” and “auxiliary-symbol” results should not be reported as the same thing. Otherwise the compliance report becomes a small theater production.

Inseparability is the hidden governance concept

One of the most useful ideas in the paper is inseparability. Two ontologies are inseparable with respect to a signature when they entail the same concept inclusions expressible in that signature.

This is the formal cousin of a very common business question:

Did this change alter the behavior that our users, partners, or downstream systems can observe?

Version control can tell us which axioms changed. Inseparability tells us whether the semantic consequences changed over a relevant vocabulary. That distinction matters in regulated or shared knowledge environments.

Imagine a medical ontology update. A syntactic diff may show that dozens of internal classifications changed. But if the public-facing diagnostic vocabulary has the same consequences as before, the external behavior may be stable. Conversely, a tiny syntactic change can alter a critical entailment. Text diff says “small change.” Logic says “quiet explosion.” Logic is the annoying one, and in this case it is right.

The paper connects this to conservative extensions, logical difference, and modules.

A conservative extension asks whether adding new terms and axioms preserves all old-signature consequences. This is valuable when extending an ontology without damaging existing users.

A logical difference asks which entailments differ between ontology versions. This is the semantic version of change tracking.

A module is a subset of the original ontology that preserves consequences over a signature. Modules are often bounded by the original ontology size and preserve the original syntactic structure, while uniform interpolants can be more compact or more signature-controlled but may rewrite the structure dramatically.

The practical choice is therefore not “modules versus interpolants.” It is:

This is where interpolation becomes less like a theorem and more like infrastructure.

Craig interpolation explains entailments, but only when the logic cooperates

Uniform interpolation works at the ontology level in much of the paper. Craig interpolation appears mainly at the concept level for description logics.

Here the application is explanation. If an ontology entails that concept $C$ is subsumed by concept $D$, a Craig interpolant can provide a middle concept using only the shared vocabulary. That middle concept can be a more intelligible explanation of why the subsumption holds.

The paper reports that many description logics enjoy the Craig interpolation property, including $\mathcal{ALC}$ and certain extensions. For those logics, if the subsumption holds, an interpolant exists in the appropriate common signature. The paper also shows that not all extensions preserve this property. Nominals and other expressive features can change the picture.

The message is subtle but important. More expressive ontology languages do not monotonically improve explainability. Adding expressive features can make some reasoning tasks easier to model while making interpolation properties fail or become harder.

That gives us a useful architecture principle:

Choose ontology expressiveness based not only on what you need to say, but also on what you need to explain, forget, modularize, and verify.

This is often missed. Teams select a richer knowledge representation language because the domain is messy. Fair enough. Domains are indeed messy; they have been doing it on purpose for centuries. But the richer language may weaken the guarantees available for downstream governance tasks.

The paper’s treatment of Craig interpolation is therefore not just theoretical. It warns that explainability is partly a language-design problem.

Beth definability turns hidden meaning into explicit rules

Craig interpolation is tightly linked to Beth definability. In practical terms, Beth definability asks whether a concept whose meaning is implicitly fixed by an ontology can be explicitly defined using a chosen vocabulary.

The paper gives a family-style example: if an ontology’s rules imply exactly who counts as Mother, can we write an explicit definition such as “woman and has a child” using the allowed symbols?

That sounds like documentation. It is stronger than documentation. Documentation can be wrong; explicit definition is a logical equivalence under the ontology.

For enterprise knowledge systems, this matters in three common places.

First, it helps ontology engineers replace implicit behavior with transparent definitions. Second, it supports referring expressions: instead of exposing an internal ID, the system can describe an entity by a meaningful concept such as “head of finance.” Third, it connects to query rewriting, where ontology-mediated queries may be transformed into queries answerable by standard database systems.

This is a clean example of symbolic AI creating operational leverage. The value is not that the system “understands” in the anthropomorphic sense. The value is that a hidden dependency can sometimes be converted into an explicit reusable expression.

Again, there is a boundary. The paper notes that explicit definitions can be very large, with double-exponential lower bounds in relevant settings. So the governance dream is not “all implicit meanings become short definitions.” The realistic dream is more modest: identify when explicit definitions exist, when they are computationally feasible, and when a compact human-readable definition is not promised by the logic.

Not every truth is a good tooltip.

Concept learning is where interpolation starts to look like symbolic machine learning

The paper also connects Craig interpolation to concept learning in description logics.

The setup is familiar: we have positive and negative examples, and we want a concept description that separates them. In description logic terms, a separator is a concept that holds for the positive examples and does not hold for the negative ones. The paper reports that, in relevant description logics with nominals, separator existence and interpolant existence are closely connected, with polynomial-time reductions between them.

This is one of the more business-relevant bridges in the chapter. It links formal reasoning to a kind of interpretable learning: instead of training a black-box classifier, we induce a logical concept description that can be inspected, reused, and checked against an ontology.

That does not make it easy. The same decidability and complexity issues remain. But it gives a serious alternative for domains where explanations are not optional: compliance classifications, biomedical concepts, industrial taxonomies, legal eligibility rules, and enterprise master-data governance.

The business inference is cautious but valuable:

Interpolation can support learning when the desired output is not merely a prediction, but a symbolic concept that must live inside an ontology.

This is not a replacement for neural learning. It is a different tool for situations where the output must be a rule-like object, not just a score.

Logic programming changes the contract because conclusions can disappear

The paper’s final technical category is logic programming, especially answer set programming under stable model semantics.

Here interpolation becomes harder to discuss because logic programming is often nonmonotonic. In monotonic logics, adding more knowledge cannot invalidate old conclusions. In nonmonotonic systems, it can. A rule that once supported an answer may stop doing so after another rule is added.

That breaks the naive transfer of Craig interpolation. The paper explains that interpolation for logic programs needs modified definitions using two entailment relations: one connected to the nonmonotonic semantics and another to its deductive base. It also distinguishes settings aligned with the open-world assumption and the closed-world assumption.

For propositional coherent programs, the paper reports existence guarantees for certain Craig-style interpolants. For coherent, function-free, safe first-order programs, it reports a corresponding existence guarantee. These restrictions are not arbitrary. Safety and function-free structure matter because practical ASP systems rely on grounding, and unrestricted first-order behavior can escape first-order definability.

Uniform interpolation in logic programming is discussed through forgetting. For propositional programs, forgetting operators satisfying properties such as consequence persistence can provide uniform interpolants. But stronger preservation notions, such as strong persistence under arbitrary program extension, are not always possible. Recognition and computation can also be expensive, with exponential blow-up risks.

The practical reading is this:

So if an enterprise uses ASP for configuration, planning, or constraint-heavy decision systems, interpolation is still relevant. But the contract is different. A deleted atom may affect not only what is stated, but which answer sets survive. The “forgetting” problem is not just vocabulary management. It is model management.

What the paper directly shows, and what Cognaptus infers for business use

The paper directly shows three things.

First, interpolation has a broad set of knowledge-representation applications: forgetting, information hiding, abduction, modularization, summarization, explanation, explicit definition, concept learning, and query rewriting.

Second, description logics have a rich but uneven interpolation landscape. Uniform interpolation for ontologies is powerful but may fail to exist and may require triple-exponential size. Craig interpolation for concepts is available in many logics, fails in others, and is tightly connected to Beth definability.

Third, logic programming requires special treatment because nonmonotonic entailment changes the behavior of interpolation and forgetting. Propositional settings have useful guarantees; first-order settings require restrictions; stronger preservation requirements may be impossible or more expensive.

Cognaptus’ business inference is that interpolation should be viewed as a semantic governance primitive for AI systems that rely on structured knowledge.

That does not mean every company needs to implement Lethe tomorrow morning. Some should not. Many organizations barely know which spreadsheet is the master ontology, a charming governance style known as “archaeology.” But for companies building serious knowledge graphs, compliance rule bases, ontology-mediated data layers, or hybrid symbolic-neural systems, the paper points toward a practical architecture.

This is not marketing magic. It is a checklist for choosing how much semantic preservation the system actually needs.

The boundary section: exactness is expensive, language choice matters, and tools are uneven

The main limitation of the paper is not a flaw. It is the nature of the subject.

This is a theoretical and survey-style chapter. Its evidence consists of definitions, theorem statements, proof sketches, known complexity results, algorithmic constructions, and tool taxonomies. It does not run a benchmark showing that one interpolation tool outperforms another on a particular enterprise ontology. So we should not read the tool discussion as a performance leaderboard.

The second boundary is expressiveness. Results change when the ontology language changes. $\mathcal{EL}$, $\mathcal{ALC}$, extensions with inverse roles, nominals, functionality restrictions, role hierarchies, and transitivity do not all behave the same. A product team cannot safely say “description logics support interpolation” without specifying the language fragment.

The third boundary is output usability. Even when an interpolant exists, it may not be short, pretty, or readable. Formal existence does not imply executive-slide friendliness. This is where approximation, module extraction, and human-facing explanation layers may be necessary.

The fourth boundary is implementation maturity. The paper notes implemented systems for uniform interpolation of description logic ontologies, but Craig interpolation and Beth definability remain more theoretical at the tool level. That matters if the use case is immediate production deployment rather than research-grade ontology engineering.

Finally, logic programming introduces a separate boundary: forgetting under nonmonotonic semantics has multiple preservation notions, and stronger forms are not always possible. In ASP, the business question must specify whether we care about projected answer sets, persistence under added facts, or persistence under arbitrary added programs. These are not the same promise with different fonts.

The quiet engineering layer beneath hybrid AI

Interpolation will not trend on social media. It has no demo where an avatar says “I understand your ontology” in a soothing voice. Shame, really; the ontology deserves better lighting.

But the paper matters because hybrid AI systems increasingly need structured knowledge to behave reliably. Retrieval can bring documents into context. LLMs can generate fluent answers. Knowledge graphs and rule systems can provide formal constraints. The difficult part is making those layers governable.

Interpolation sits in that governance layer. It helps answer questions such as:

• What can a partner infer after we hide internal vocabulary?
• Did an ontology update preserve the public-facing meaning?
• Can we explain this entailment using only concepts the auditor understands?
• Can an implicit classification be turned into an explicit rule?
• Can a complex ontology-mediated query be rewritten for cheaper execution?
• Can a rule program forget an atom without changing the answer sets we care about?

These are not glamorous questions. They are the questions that appear after the prototype works and before the system is trusted.

The paper’s deeper lesson is that reasoning systems do not merely store facts. They preserve consequences. They leak through entailments. They compress meaning through hidden symbols. They fail gracefully only when the engineering contract says what kind of semantic preservation is being attempted.

So, yes, mind the gap.

Not the one between symbolic AI and neural AI. The more dangerous one between deleting a term and deleting what the system can still infer from it.

Cognaptus: Automate the Present, Incubate the Future.