💻 computer science

Moose: Latent concept learning with reasoning-shortcut awareness in $\mathcal{EL}^{++}$

This paper introduces Moose, a neuro-symbolic method that compiles $\mathcal{EL}^{++}$ ontologies into differentiable Sentential Decision Diagrams to enable the first reasoning-shortcut-aware latent concept learning under partial supervision, outperforming existing baselines on ontology-based tasks.

Original authors: Olga Mashkova, Asaad Mohammedsaleh, Fernando Zhapa-Camacho, Robert Hoehndorf

Published 2026-08-14

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Olga Mashkova, Asaad Mohammedsaleh, Fernando Zhapa-Camacho, Robert Hoehndorf

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

The Puzzle of the Hidden Mind

Imagine you are trying to teach a robot to understand the world. You have two powerful tools in your toolbox. The first is Neural Networks, which are like super-fast pattern recognizers. They are great at looking at a picture of a cat and saying, "That's a cat!" because they've seen millions of cats before. But they are a bit like a magic trick; they guess based on patterns, and sometimes they get confused or make up rules that don't make sense. The second tool is Symbolic Logic, which is like a strict rulebook. It says, "If a cat has whiskers and a tail, it is a mammal." It never guesses; it follows the rules perfectly. But it's terrible at looking at a blurry photo and figuring out what it is.

For a long time, scientists have been trying to combine these two tools into one super-brain, a field called Neuro-symbolic AI. The goal is to have a system that can see a picture (like a neural network) but also understand the deep rules of how things fit together (like a logician). However, there's a tricky problem: when the robot doesn't have all the facts, it sometimes finds a "shortcut." It might learn to guess the answer correctly just by looking at a tiny, irrelevant detail, rather than actually understanding the big picture. This is called a Reasoning Shortcut. It's like a student who memorizes the answer key for a specific test but fails to learn the actual math. The big question in this field is: Can we build a system that learns the real rules, even when we only give it partial clues, without falling for these shortcuts?

Moose: The Detective Who Checks the Rules

This paper introduces a new method called Moose (which stands for something technical, but let's just think of it as a clever detective). Moose is designed to solve a specific puzzle: teaching a robot to figure out hidden facts about things it sees, using a strict set of logical rules called an OWL 2 EL ontology. Think of an ontology as a massive, pre-written encyclopedia of rules. For example, in a biology encyclopedia, it might say, "All cats are mammals" and "No mammals are plants."

The challenge Moose tackles is what happens when you show the robot a picture (like a digit from the MNIST dataset) and tell it, "This number is even," but you don't tell it what the number actually is. The robot has to guess the number (the hidden concept) while making sure its guess fits the encyclopedia's rules.

Here is how Moose works, step-by-step:

The Rulebook Compiler: First, Moose takes the massive encyclopedia (the ontology) and translates it into a special kind of map called a Sentential Decision Diagram (SDD). Imagine taking a giant, tangled ball of yarn representing all the rules and untangling it into a neat, organized flowchart. This map is special because it can be "weighted," meaning the robot can assign probabilities to different paths.
The Logic Check: When the robot looks at an image and makes a guess (e.g., "I think this is a 4"), Moose doesn't just accept it. It runs the guess through the flowchart. If the guess breaks the rules (e.g., the robot thinks it's a 4, but the rules say 4 is odd, which is a contradiction), the system knows something is wrong.
The "Shortcut" Fix: This is where Moose gets really smart. Sometimes, the robot finds a shortcut. For instance, if the robot sees a picture of a 4 and the rule says "4 is even," it might just learn to always guess "even" whenever it sees a 4, without actually learning what a 4 looks like. Moose adds extra "closure" rules to the flowchart. These rules act like a safety net, forcing the robot to consider all possibilities that fit the clues, not just the easiest one. It's like telling the student, "You can't just guess 'even' because you saw a 4; you have to prove it fits every single rule in the book."

What Moose Found

The authors tested Moose on two main challenges: a digital version of the famous MNIST digit dataset (where they added logic rules about numbers being prime, even, or odd) and a synthetic dataset of pizzas with different toppings.

Avoiding Shortcuts: In experiments where the robot had to figure out hidden relationships (like if one number leads to another), Moose was significantly better than other methods. While other systems often fell for "reasoning shortcuts" (guessing the answer based on a tiny clue), Moose stuck to the rules. For example, in a test involving role chains (where A leads to B, and B leads to C), Moose achieved 96.1% accuracy, while the next best method only got 59.6%.
The Trade-off: The paper also found that there is a balance between being accurate (getting the right answer) and being calibrated (knowing how sure you are). When the rules were ambiguous (like a pizza that could be two different types), Moose had to choose between two strategies:
- BEARS: This version uses a team of robots to vote. It was better at getting the right answer (accuracy) but sometimes was too confident when it was wrong.
- NeSyDM: This version uses a different kind of math to spread out its guesses. It was better at knowing when it was unsure (calibration) but sometimes got the answer slightly less often.
The "Closure" Secret: The paper proved that without adding those extra "closure" rules (the safety net), the system would fail almost completely, dropping to near-random guessing (around 9.4% accuracy in one test). This showed that the extra rules weren't just helpful; they were essential for the robot to learn the hidden concepts correctly.

The Bottom Line

Moose is a new way to teach AI to learn hidden facts by strictly following a rulebook. It proved that by translating complex logic rules into a special, efficient map, a robot can learn to reason correctly even when it only sees part of the picture. The authors showed that without specific safeguards against "shortcuts," AI systems will often find simplified ways to solve problems. Moose fixes this by forcing the system to check every possibility against the rules.

While the paper is a major step forward, the authors are careful to note that this works best on smaller, defined sets of data. They haven't yet tested it on the massive, real-world databases used by hospitals or the entire internet, so while Moose is a powerful new tool, it's still being refined for the biggest challenges. But for now, it's a brilliant example of how combining a robot's eyes with a logician's brain can lead to smarter, more honest AI.

Technical Summary: Moose – Latent Concept Learning with Reasoning-Shortcut Awareness in EL++

1. Problem Statement

The paper addresses the challenge of ABox-supervised latent concept learning within the OWL 2 EL profile. OWL 2 EL underpins major production ontologies (e.g., Gene Ontology, SNOMED CT) due to its polynomial-time reasoning capabilities, but it lacks native support for right-hand-side disjunction and cardinality constraints.

The specific learning task involves:

Input: Per-individual perceptual data (e.g., images) and a partial set of observed ABox literals over an observable signature.
Goal: Learn per-individual classifiers for the truth values of latent concept atoms (unobserved concepts) that are not directly supervised.
Constraints: The learning must respect the entailments of the EL++ ontology, including role chains ( $R_1 \circ R_2 \sqsubseteq S$ ) and role hierarchies.
The Challenge: Existing neuro-symbolic (NeSy) frameworks typically accept propositional formulas or Datalog, not OWL ontologies directly. Furthermore, under partial supervision, standard NeSy predictors often suffer from Reasoning Shortcuts (RS): they learn to assign high confidence to a single arbitrary latent configuration that satisfies the evidence, rather than distributing probability mass over all valid configurations, due to the assumption of per-atom independence.

2. Methodology: The Moose Framework

Moose is an end-to-end method that compiles an EL++ TBox and a finite ABox domain into a Sentential Decision Diagram (SDD), which serves as a differentiable Weighted Model Counting (WMC) layer.

Core Pipeline

ELK Saturation (Stage 1): The method runs the ELK saturation calculus on the input ontology to derive all entailed subsumptions and role links. This produces a saturation closure $(\Sigma, \Lambda)$ .
TBox-Level Encoding (Stages 2–5): The saturation is converted into a propositional theory using Clark completion, Strongly Connected Component (SCC) detection, time-stamped unrolling for cyclic dependencies, and Tseitin transformation to CNF. This stage handles the logical structure but is primarily diagnostic for the learning task.
Shape-Aware Grounding (Stage 6): Extractors filter the saturation closure to retain only ground ABox atoms relevant to the named individuals in the finite domain $\Delta$ $Δ$ . This generates a propositional Horn program $\Gamma_{EL}$ $Γ_{E L}$ over the ground vocabulary.
- Note: Deeply nested existential derivations (internal to ELK) are filtered out as they have no ground counterpart in the finite named domain.
SDD Compilation (Stage 7): The grounded clauses are compiled into an SDD. This circuit is smooth, decomposable, and deterministic, enabling exact and differentiable WMC.
Closure Augmentation: To address the limited expressivity of EL++ (specifically the lack of closed-world assumptions and right-hand-side disjunction), the method optionally appends closure axioms ( $\Phi_{clos}$ ) for declared exhaustive families. These include pairwise disjointness, covering clauses, and profile-keyed reverse implications. This step is crucial for providing a non-trivial learning gradient under partial supervision.

Learning and Inference

Training: A neural network $f_\theta$ maps inputs to per-atom probabilities. These probabilities serve as literal weights for the SDD. The training loss is the negative log-WMC: $L(\theta) = -\log \text{WMC}(\alpha; p_\theta(x), e)$ .
Reasoning Shortcuts Mitigation: The paper integrates two existing RS-mitigation strategies adapted for the OWL EL setting:
- Moose+BEARS: Trains an ensemble of encoders diversified via KL divergence to prevent collapse to a single shortcut.
- Moose+NeSyDM: Replaces the factorized independence assumption with a masked discrete-diffusion model to capture cross-atom dependencies.

3. Key Contributions

The paper claims four primary contributions:

End-to-End OWL 2 EL Compilation with Formal Proofs:
- Compiles the full EL profile (including role chains and hierarchies) into an SDD supporting WMC.
- Provides four formal theorems verified in Lean 4:
  - Theorem 1: Verified SDD encoding (models of the SDD correspond exactly to worlds where the ontology entails the query).
  - Theorem 2: Rational DISPONTE correspondence (the WMC of the circuit equals the probabilistic entailment under distribution semantics).
  - Theorems 3 & 4: SCC-compositional factorizations at the Sat and WMC levels, proving that irrelevant components do not affect derivability or posterior probabilities.
- All proofs are mechanized without Moose-specific axioms, relying only on standard Lean foundations.
ABox-Supervised Latent Concept Learning:
- Defines the first formal task for learning latent concept classifiers from observed ABox literals over an OWL EL ontology.
- Generalizes DeepProbLog and Semantic Loss to description logic constraints involving role chains and hierarchies.
Reasoning-Shortcut Analysis in OWL EL:
- Transposes the formal analysis of reasoning shortcuts (previously limited to propositional/Datalog settings) to the OWL EL setting.
- Evaluates the trade-off between family-argmax accuracy (BEARS excels here) and Expected Calibration Error (ECE) (NeSyDM excels here) under symbolic ambiguity.
Benchmark Suite:
- Introduces MNIST-with-ontology (OMNIST) covering atomic, relational, and role-chain supervision regimes.
- Introduces Pizza¨ıolo, a synthetic dataset based on the OWL Pizza ontology, to test transfer to a real-world, third-party ontology.

4. Experimental Results

The paper evaluates Moose against propositional NeSy baselines (DeepProbLog, Semantic Loss), fuzzy logic (LTN), and ontology embeddings (ELEmbeddings).

Relational and Role-Chain Regimes (MNIST): Moose significantly outperforms propositional baselines.
- On the role-chain experiment (Exp 3), Moose achieves 96.1% accuracy compared to 59.6% for DeepProbLog.
- Ablation: Removing the closure axioms ( $\Phi_{clos}$ ) causes performance to collapse to near-chance levels (e.g., dropping from 96.1% to 9.4%), demonstrating that the EL-aware grounding provides structure, but the closure axioms provide the necessary identifying constraints for learning.
Symbolic Ambiguity (Pizza¨ıolo):
- In regimes with high symbolic ambiguity (e.g., 3-way ambiguity in Track B), BEARS improves accuracy (87.9% vs 84.5% for plain Moose) by diversifying predictions.
- NeSyDM achieves the best calibration (lowest ECE) but often at the cost of accuracy.
- Inductive Generalization: Moose maintains accuracy on held-out relational configurations, whereas NeSyDM collapses, indicating Moose's reliance on the exact inference path rather than memorized edge identities.
Calibration vs. Accuracy: A trade-off is observed: BEARS leads in accuracy under ambiguity, while NeSyDM leads in calibration.

5. Significance and Claims

The paper positions Moose as the first method to provide:

Exact, Differentiable Reasoning for OWL EL: By compiling EL++ directly to an SDD, it retains the exact model-theoretic semantics of the ontology while enabling gradient-based learning, unlike fuzzy approximations or embedding methods that relax semantics.
Formal Verification: The compilation and correctness proofs are mechanized in Lean 4, offering a high degree of trust in the reasoning signal used for training.
RS Awareness in Ontologies: It is the first to formally analyze and mitigate reasoning shortcuts within the context of OWL EL, showing that standard propositional NeSy failures translate directly to ontology-driven systems.

Limitations Acknowledged by the Authors:

Scale: Experiments are limited to small ABox domains ( $|\Delta| \le 2$ ). The SDD size grows empirically as $|\Delta|^{2.9}$ , and the method does not yet scale to massive ontologies like SNOMED CT without lifted WMC techniques.
Finite Domain: The method assumes a finite set of named individuals and does not perform open-domain inference over unnamed individuals.
Role-Pinning: The soundness of the role-link encoding relies on the assumption that role atoms over the observable signature are pinned by evidence, a specific choice for the finite-named-domain regime rather than a general ELK theorem.

The authors conclude that while the theoretical contribution (verified compilation and RS analysis) stands independently, the scalability to production-scale ontologies remains an open problem requiring lifted WMC.