rustdl 0.3.2__tar.gz → 0.3.4__tar.gz

{rustdl-0.3.2 → rustdl-0.3.4}/Cargo.lock

@@ -1037,7 +1037,7 @@ checksum = "384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe"
 
 [[package]]
 name = "owl-dl-bench"
-version = "0.3.2"
+version = "0.3.4"
 dependencies = [
  "anyhow",
  "clap",
@@ -1054,7 +1054,7 @@ dependencies = [
 
 [[package]]
 name = "owl-dl-cli"
-version = "0.3.2"
+version = "0.3.4"
 dependencies = [
  "anyhow",
  "clap",
@@ -1066,7 +1066,7 @@ dependencies = [
 
 [[package]]
 name = "owl-dl-core"
-version = "0.3.2"
+version = "0.3.4"
 dependencies = [
  "bitvec",
  "bumpalo",
@@ -1080,7 +1080,7 @@ dependencies = [
 
 [[package]]
 name = "owl-dl-datatypes"
-version = "0.3.2"
+version = "0.3.4"
 dependencies = [
  "owl-dl-core",
  "proptest",
@@ -1090,7 +1090,7 @@ dependencies = [
 
 [[package]]
 name = "owl-dl-py"
-version = "0.3.2"
+version = "0.3.4"
 dependencies = [
  "horned-owl",
  "owl-dl-core",
@@ -1101,7 +1101,7 @@ dependencies = [
 
 [[package]]
 name = "owl-dl-reasoner"
-version = "0.3.2"
+version = "0.3.4"
 dependencies = [
  "dashmap",
  "horned-owl",
@@ -1117,7 +1117,7 @@ dependencies = [
 
 [[package]]
 name = "owl-dl-saturation"
-version = "0.3.2"
+version = "0.3.4"
 dependencies = [
  "dashmap",
  "fixedbitset",
@@ -1133,7 +1133,7 @@ dependencies = [
 
 [[package]]
 name = "owl-dl-tableau"
-version = "0.3.2"
+version = "0.3.4"
 dependencies = [
  "bitvec",
  "bumpalo",
@@ -2569,7 +2569,7 @@ dependencies = [
 
 [[package]]
 name = "xtask"
-version = "0.3.2"
+version = "0.3.4"
 dependencies = [
  "anyhow",
  "clap",

{rustdl-0.3.2 → rustdl-0.3.4}/Cargo.toml

@@ -3,7 +3,7 @@ resolver = "2"
 members = ["crates/owl-dl-core", "crates/owl-dl-saturation", "crates/owl-dl-tableau", "crates/owl-dl-datatypes", "crates/owl-dl-reasoner", "crates/owl-dl-py"]
 
 [workspace.package]
-version = "0.3.2"
+version = "0.3.4"
 edition = "2024"
 rust-version = "1.88"
 license = "Apache-2.0 OR MIT"
@@ -15,11 +15,11 @@ keywords = ["owl", "ontology", "reasoner", "description-logic", "semantic-web"]
 categories = ["science", "data-structures"]
 
 [workspace.dependencies]
-owl-dl-core = { path = "crates/owl-dl-core", version = "0.3.2" }
-owl-dl-saturation = { path = "crates/owl-dl-saturation", version = "0.3.2" }
-owl-dl-tableau = { path = "crates/owl-dl-tableau", version = "0.3.2" }
-owl-dl-datatypes = { path = "crates/owl-dl-datatypes", version = "0.3.2" }
-owl-dl-reasoner = { path = "crates/owl-dl-reasoner", version = "0.3.2" }
+owl-dl-core = { path = "crates/owl-dl-core", version = "0.3.4" }
+owl-dl-saturation = { path = "crates/owl-dl-saturation", version = "0.3.4" }
+owl-dl-tableau = { path = "crates/owl-dl-tableau", version = "0.3.4" }
+owl-dl-datatypes = { path = "crates/owl-dl-datatypes", version = "0.3.4" }
+owl-dl-reasoner = { path = "crates/owl-dl-reasoner", version = "0.3.4" }
 
 horned-owl = { version = "1.4", default-features = false }
 

{rustdl-0.3.2 → rustdl-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rustdl
-Version: 0.3.2
+Version: 0.3.4
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: Apache Software License

{rustdl-0.3.2 → rustdl-0.3.4}/crates/owl-dl-core/src/convert.rs

@@ -527,6 +527,11 @@ pub fn convert_ontology<A: ForIRI>(
         })
     };
     out.axioms.extend(derived);
+    // Derive `X ⊑ ∃R.C` from `X ⊑ ∃R.(D₁ ⊔ … ⊔ Dₙ)` when the disjuncts
+    // share a told-subsumer C (sound under-approximation; feeds the EL
+    // saturator a case-split it otherwise drops). Runs on the fully
+    // populated IR.
+    crate::disjunction_existential::derive_disjunction_existentials(&mut out);
     out.axioms.sort();
     Ok(out)
 }

rustdl-0.3.4/crates/owl-dl-core/src/disjunction_existential.rs

@@ -0,0 +1,219 @@
+//! Preprocessing pass: derive `X ⊑ ∃R.C` from
+//! `X ⊑ ∃R.(D₁ ⊔ … ⊔ Dₙ)` when all disjuncts share a told-subsumer `C`.
+//!
+//! ## Why
+//!
+//! The consequence-based EL saturator drops existentials whose filler is
+//! a disjunction (`∃R.(D₁ ⊔ … ⊔ Dₙ)` is out of EL). But when every
+//! disjunct shares a common subsumer `C` — i.e. `Dᵢ ⊑ C` for all `i` —
+//! the disjunction is eliminable by cases: `(D₁ ⊔ … ⊔ Dₙ) ⊑ C`, hence
+//! `∃R.(D₁ ⊔ … ⊔ Dₙ) ⊑ ∃R.C`. Feeding the saturator the derived
+//! `X ⊑ ∃R.C` lets it close subsumptions that otherwise need a full
+//! tableau case-split.
+//!
+//! This is a **sound under-approximation**: every emitted axiom is
+//! entailed, and we only use *told* (explicit, transitively-closed)
+//! subsumers of *atomic* disjuncts, so no false positive is possible.
+//! Cases where the common subsumer is only *derived* (not told), or a
+//! disjunct is non-atomic, are left to the tableau/wedge.
+//!
+//! ## Impact
+//!
+//! Closes the SIO corpus MISSES `SIO_010092 ⊑ SIO_001353` and
+//! `SIO_010092 ⊑ SIO_010410`: `SIO_010092` (DNA template) is
+//! `⊑ ∃has-function.(template-for-RNA ⊔ template-for-DNA)`, both
+//! disjuncts `⊑` `SIO_010088` (template-for-molecular-synthesis)
+//! `⊑ realizable-entity`, and `has-function ⊑* has-realizable-property`.
+
+use crate::ir::{ClassId, ConceptExpr, ConceptId, ConceptPool, Role};
+use crate::ontology::{Axiom, InternalOntology};
+use crate::told::{ToldTables, build_told_tables};
+
+/// Scan `onto` for `SubClassOf(X, ∃R.(union-of-atomics))` (directly, or
+/// as a conjunct of a top-level `And`) and append a derived
+/// `SubClassOf(X, ∃R.C)` for each *minimal* common told-subsumer `C` of
+/// the disjuncts. See the module docs for soundness.
+pub fn derive_disjunction_existentials(onto: &mut InternalOntology) {
+    let told = build_told_tables(onto);
+    // Phase 1 (immutable borrow): collect (sub, role, common-class).
+    let mut triples: Vec<(ConceptId, Role, ClassId)> = Vec::new();
+    for ax in &onto.axioms {
+        let Axiom::SubClassOf { sub, sup } = ax else {
+            continue;
+        };
+        collect_from_sup(*sub, *sup, &onto.concepts, &told, &mut triples);
+    }
+    if triples.is_empty() {
+        return;
+    }
+    // Phase 2 (mutable borrow): intern the derived existentials + push.
+    for (sub, role, c) in triples {
+        let body = onto.concepts.atomic(c);
+        let sup = onto.concepts.some(role, body);
+        if sub == sup {
+            continue;
+        }
+        onto.axioms.push(Axiom::SubClassOf { sub, sup });
+    }
+}
+
+/// Handle a single `SubClassOf` super-concept: a direct `∃R.(union)` or
+/// each `∃R.(union)` conjunct of a top-level `And`.
+fn collect_from_sup(
+    sub: ConceptId,
+    sup: ConceptId,
+    pool: &ConceptPool,
+    told: &ToldTables,
+    out: &mut Vec<(ConceptId, Role, ClassId)>,
+) {
+    match pool.get(sup) {
+        ConceptExpr::Some(role, body) => {
+            for c in minimal_common_subsumers(*body, pool, told) {
+                out.push((sub, *role, c));
+            }
+        }
+        ConceptExpr::And(operands) => {
+            for &op in operands {
+                if let ConceptExpr::Some(role, body) = pool.get(op) {
+                    for c in minimal_common_subsumers(*body, pool, told) {
+                        out.push((sub, *role, c));
+                    }
+                }
+            }
+        }
+        _ => {}
+    }
+}
+
+/// If `body` is `Or(D₁, …, Dₙ)` with all `Dᵢ` atomic and `n ≥ 2`,
+/// return the *minimal* (most specific) classes `C` such that every
+/// `Dᵢ ⊑ C` is told. Empty otherwise.
+fn minimal_common_subsumers(
+    body: ConceptId,
+    pool: &ConceptPool,
+    told: &ToldTables,
+) -> Vec<ClassId> {
+    let ConceptExpr::Or(disjuncts) = pool.get(body) else {
+        return Vec::new();
+    };
+    let mut atoms: Vec<ClassId> = Vec::with_capacity(disjuncts.len());
+    for &d in disjuncts {
+        match pool.get(d) {
+            ConceptExpr::Atomic(c) => atoms.push(*c),
+            // A non-atomic disjunct (nested ∃, And, …) is left to the
+            // tableau — keep this pass a sound under-approximation.
+            _ => return Vec::new(),
+        }
+    }
+    if atoms.len() < 2 {
+        return Vec::new();
+    }
+    // Intersection of the (reflexive, transitively-closed, sorted)
+    // told-super-class sets. Reflexivity is sound here: a disjunct `Dᵢ`
+    // lands in the intersection only if it told-subsumes every other
+    // disjunct, in which case `Dᵢ ⊒ (D₁ ⊔ … ⊔ Dₙ)` and `∃R.Dᵢ` holds.
+    let mut common: Vec<ClassId> = told.super_classes(atoms[0]).to_vec();
+    for &a in &atoms[1..] {
+        let supers = told.super_classes(a);
+        common.retain(|c| supers.binary_search(c).is_ok());
+        if common.is_empty() {
+            return Vec::new();
+        }
+    }
+    // Keep only minimal elements: drop `C` if some other common `C'` is
+    // told-below `C` (the saturator recovers the weaker supers from the
+    // minimal ones, so emitting the whole chain is redundant).
+    common
+        .iter()
+        .copied()
+        .filter(|&c| {
+            !common
+                .iter()
+                .any(|&other| other != c && told.is_told_sub(other, c))
+        })
+        .collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::ir::{ConceptExpr, Role};
+    use horned_owl::io::ParserConfiguration;
+    use horned_owl::io::ofn::reader::read;
+    use horned_owl::model::RcStr;
+    use horned_owl::ontology::set::SetOntology;
+    use std::io::Cursor;
+
+    /// The SIO pattern: `X ⊑ ∃R.(D1 ⊔ D2)` with `D1,D2 ⊑ E ⊑ F`. The
+    /// pass (run inside `convert_ontology`) must add `X ⊑ ∃R.E` (E is
+    /// the minimal common told-subsumer), and must NOT add the weaker
+    /// `X ⊑ ∃R.F` (only minimal subsumers). Mirrors `SIO_010092`'s
+    /// `∃has-function.(template-RNA ⊔ template-DNA)`.
+    #[test]
+    fn pass_emits_minimal_common_subsumer_existential() {
+        let src = "\
+Prefix(:=<http://t.org/#>)
+Ontology(
+  Declaration(Class(:X)) Declaration(Class(:D1)) Declaration(Class(:D2))
+  Declaration(Class(:E)) Declaration(Class(:F))
+  Declaration(ObjectProperty(:R))
+  SubClassOf(:X ObjectSomeValuesFrom(:R ObjectUnionOf(:D1 :D2)))
+  SubClassOf(:D1 :E) SubClassOf(:D2 :E) SubClassOf(:E :F)
+)
+";
+        let (set_onto, _): (SetOntology<RcStr>, _) =
+            read(&mut Cursor::new(src), ParserConfiguration::default()).expect("parses");
+        // convert_ontology runs the pass.
+        let onto = crate::convert::convert_ontology(&set_onto).expect("converts");
+        let cid = |iri: &str| onto.vocabulary.class_id(iri).expect("declared");
+        let x = cid("http://t.org/#X");
+        let e = cid("http://t.org/#E");
+        let f = cid("http://t.org/#F");
+
+        let some_class = |target| {
+            onto.axioms.iter().any(|ax| {
+                if let crate::ontology::Axiom::SubClassOf { sub, sup } = ax {
+                    matches!(onto.concepts.get(*sub), ConceptExpr::Atomic(c) if *c == x)
+                        && matches!(onto.concepts.get(*sup),
+                            ConceptExpr::Some(Role::Named(_), body)
+                                if matches!(onto.concepts.get(*body), ConceptExpr::Atomic(c) if *c == target))
+                } else {
+                    false
+                }
+            })
+        };
+        assert!(
+            some_class(e),
+            "expected derived X ⊑ ∃R.E (minimal common subsumer)"
+        );
+        assert!(
+            !some_class(f),
+            "should NOT emit the non-minimal X ⊑ ∃R.F (E ⊑ F already covers it)"
+        );
+    }
+
+    /// No common subsumer ⇒ no derived axiom (and no panic).
+    #[test]
+    fn pass_no_common_subsumer_emits_nothing() {
+        let src = "\
+Prefix(:=<http://t.org/#>)
+Ontology(
+  Declaration(Class(:X)) Declaration(Class(:D1)) Declaration(Class(:D2))
+  Declaration(ObjectProperty(:R))
+  SubClassOf(:X ObjectSomeValuesFrom(:R ObjectUnionOf(:D1 :D2)))
+)
+";
+        let (set_onto, _): (SetOntology<RcStr>, _) =
+            read(&mut Cursor::new(src), ParserConfiguration::default()).expect("parses");
+        let onto = crate::convert::convert_ontology(&set_onto).expect("converts");
+        let x = onto.vocabulary.class_id("http://t.org/#X").expect("X");
+        // The only ∃R.* axiom on X is the original union; no atomic-body
+        // existential was derived (D1, D2 share no told subsumer).
+        let derived = onto.axioms.iter().any(|ax| {
+            matches!(ax, crate::ontology::Axiom::SubClassOf { sub, sup }
+                if matches!(onto.concepts.get(*sub), ConceptExpr::Atomic(c) if *c == x)
+                    && matches!(onto.concepts.get(*sup),
+                        ConceptExpr::Some(_, body) if matches!(onto.concepts.get(*body), ConceptExpr::Atomic(_))))
+        });
+        assert!(!derived, "no common subsumer ⇒ nothing derived");
+    }
+}

{rustdl-0.3.2 → rustdl-0.3.4}/crates/owl-dl-core/src/lib.rs

@@ -13,6 +13,7 @@ pub mod convert;
 pub mod convert_back;
 pub mod data_axioms;
 pub mod definitions;
+pub mod disjunction_existential;
 pub mod ir;
 pub mod locality;
 pub mod normalize;

{rustdl-0.3.2 → rustdl-0.3.4}/crates/owl-dl-reasoner/tests/konclude_closure_diff.rs

@@ -378,6 +378,46 @@ fn sio_closure_matches_konclude() {
     assert_eq!(fp, 0, "sio has FPs — D1 sound-under-approximation broken");
 }
 
+#[test]
+#[ignore = "needs ontologies/real/wine.ofn + konclude-input/wine-classified.owx \
+            (W3C wine+food merged, circular imports stripped; HermiT oracle). \
+            SHOIN(D): nominal- + disjointness-heavy expressivity stressor. \
+            Fetch via scripts/fetch-real-ontologies.sh."]
+fn wine_closure_matches_konclude() {
+    let input = Path::new("../../ontologies/real/wine.ofn");
+    let truth = Path::new("../../ontologies/real/konclude-input/wine-classified.owx");
+    if !input.exists() || !truth.exists() {
+        eprintln!("SKIP: missing wine fixture");
+        return;
+    }
+    let (_r, _k, fp, _m) = diff_corpus_ontology("wine", input, truth, 200);
+    assert_eq!(
+        fp, 0,
+        "wine has FPs — soundness regression on nominals/datatypes"
+    );
+}
+
+#[test]
+#[ignore = "needs ontologies/real/bibtex.ofn + konclude-input/bibtex-classified.owx \
+            (ORE-2015 ore_ont_3341, a BibTeX ontology; HermiT oracle). \
+            Datatype-heavy + real class hierarchy: 41 DataMinCardinality + 40 \
+            DataPropertyDomain + 39 DataPropertyRange, 15 classes, 56 inferred \
+            edges — exercises Phase-D classification on real data. Fetch via \
+            scripts/fetch-real-ontologies.sh."]
+fn bibtex_closure_matches_konclude() {
+    let input = Path::new("../../ontologies/real/bibtex.ofn");
+    let truth = Path::new("../../ontologies/real/konclude-input/bibtex-classified.owx");
+    if !input.exists() || !truth.exists() {
+        eprintln!("SKIP: missing bibtex fixture");
+        return;
+    }
+    let (_r, _k, fp, _m) = diff_corpus_ontology("bibtex", input, truth, 200);
+    assert_eq!(
+        fp, 0,
+        "bibtex has FPs — Phase-D sound-under-approximation broken"
+    );
+}
+
 #[test]
 #[ignore = "needs ontologies/real/ro.ofn + konclude-input/ro-classified.owx; Phase D1 fixture (was UnsupportedAxiom-erroring pre-D1; HermiT oracle generated 2026-06-03)"]
 fn ro_closure_matches_konclude() {

{rustdl-0.3.2 → rustdl-0.3.4}/crates/owl-dl-saturation/src/lib.rs

@@ -53,8 +53,8 @@ use std::collections::{HashMap, HashSet, VecDeque};
 
 use fixedbitset::FixedBitSet;
 use owl_dl_core::{
-    Axiom, ClassId, ConceptExpr, ConceptId, ConceptPool, InternalOntology, Role, RoleId,
-    SubRolePath,
+    Axiom, ClassId, ConceptExpr, ConceptId, ConceptPool, IndividualId, InternalOntology, Role,
+    RoleId, SubRolePath,
 };
 
 /// Compute the subsumer closure over the EL-fragment subset of
@@ -676,6 +676,22 @@ impl WorklistEngine {
     #[allow(clippy::too_many_lines)]
     fn process_fact(&mut self, idx: usize) {
         let fact = self.facts[idx];
+        // Nominal/ABox transitive propagation: if `fact` is
+        // `X ⊑ ∃R.{a}` (target is a NomKey) and `R` is transitive with
+        // `a R⁺ b` in the ABox, derive `X ⊑ ∃R.{b}`. Sound: `X R a`,
+        // `a R⁺ b`, `R` transitive ⟹ `X R b`. See `build_abox_nominal_reach`.
+        if !self.rules.abox_nominal_reach.is_empty()
+            && let Some(reach) = self.rules.abox_nominal_reach.get(&(fact.role, fact.target))
+        {
+            let derived: Vec<ClassId> = reach.clone();
+            for b_key in derived {
+                self.push_fact(ExistentialFact {
+                    sub: fact.sub,
+                    role: fact.role,
+                    target: b_key,
+                });
+            }
+        }
         let role_supers = supers_of(&self.role_super, fact.role);
         // NOTE: range propagation deliberately omitted.
         //
@@ -1034,6 +1050,16 @@ struct ElRules {
     /// Pairwise disjoint atomic-class pairs, decomposed from n-ary
     /// `DisjointClasses` axioms. Read as `A ⊓ B ⊑ ⊥`.
     disjoint_pairs: Vec<(ClassId, ClassId)>,
+    /// Nominal-reasoning support (wine region cluster). For a
+    /// **transitive** role `R` and a nominal-key class `NomKey(a)`
+    /// (synthetic stand-in for the singleton `{a}`),
+    /// `abox_nominal_reach[(R, NomKey(a))]` lists `NomKey(b)` for every
+    /// individual `b` reachable from `a` via the transitive closure of
+    /// `R` over the named-individual `ABox`. Lets a fact
+    /// `X ⊑ ∃R.{a}` derive `X ⊑ ∃R.{b}` (sound: `X R a`, `a R⁺ b`,
+    /// `R` transitive ⟹ `X R b`). Empty unless the ontology has both
+    /// nominal existential bodies and transitive-role `ABox` edges.
+    abox_nominal_reach: std::collections::HashMap<(RoleId, ClassId), Vec<ClassId>>,
     /// Atomic classes told directly to be unsatisfiable via
     /// `SubClassOf(Atomic(C), Bot)`. Seeded into the unsat worklist
     /// at `seed` time so the standard `process_unsat` propagation
@@ -1146,6 +1172,12 @@ struct TseitinAllocator {
     /// by `(role, body_class_id)` so repeated occurrences of the same
     /// `∃R.B` shape across different conjunctions share one marker.
     by_existential: HashMap<(RoleId, ClassId), ClassId>,
+    /// Stable synthetic atomic class per individual used as a nominal
+    /// (`{a}`) in an existential body. Treated as an opaque atom
+    /// (no subsumers, no triggers) — a 1:1 structural stand-in so the
+    /// EL fold of `C ≡ D ⊓ ∃R.{a}` fires on the same key the fact
+    /// `X ⊑ ∃R.{a}` produced. Injective, so no two individuals merge.
+    nominal_by_ind: HashMap<IndividualId, ClassId>,
 }
 
 impl TseitinAllocator {
@@ -1154,9 +1186,23 @@ impl TseitinAllocator {
             next_id: u32::try_from(num_original_classes).expect("class count fits in u32"),
             by_body: HashMap::new(),
             by_existential: HashMap::new(),
+            nominal_by_ind: HashMap::new(),
         }
     }
 
+    /// Get-or-allocate the opaque synthetic atomic class standing in for
+    /// the nominal `{ind}`. Sound: matching is by individual identity
+    /// (structural), so `∃R.{a}` folds only against the same `a`.
+    fn introduce_nominal(&mut self, ind: IndividualId) -> ClassId {
+        if let Some(&existing) = self.nominal_by_ind.get(&ind) {
+            return existing;
+        }
+        let synthetic = ClassId::new(self.next_id);
+        self.next_id = self.next_id.checked_add(1).expect("synthetic id overflow");
+        self.nominal_by_ind.insert(ind, synthetic);
+        synthetic
+    }
+
     fn introduce(&mut self, mut body: Vec<ClassId>, rules: &mut ElRules) -> ClassId {
         body.sort();
         body.dedup();
@@ -1362,6 +1408,12 @@ fn collect_el_rules(
             _ => {}
         }
     }
+
+    // Nominal/ABox transitive propagation (wine region cluster).
+    // Allocates NomKeys for ABox individuals, so it must run before
+    // `total_classes` is captured.
+    build_abox_nominal_reach(internal, &mut tseitin, &mut rules);
+
     let total_classes = tseitin.next_id as usize;
 
     // Phase 2a: collect functional-role declarations and precompute
@@ -1638,6 +1690,15 @@ fn atomic_existential_rhs(
     if role.is_inverse() {
         return None;
     }
+    // Nominal body `∃R.{a}`: emit the bare per-individual NomKey, NOT a
+    // range-wrapped synthetic. The wrap (`NomKey ⊓ Range(R)`) would make
+    // the fact target a fresh synthetic, defeating the `abox_nominal_reach`
+    // lookup in `process_fact` (keyed on the bare NomKey). Dropping the
+    // range-typing of the witness is a sound under-approximation — the
+    // nominal fold needs only the NomKey identity.
+    if let ConceptExpr::Nominal(ind) = pool.get(*body) {
+        return Some((role.role_id(), tseitin.introduce_nominal(*ind)));
+    }
     let extras = effective_ranges
         .get(&role.role_id())
         .map_or(&[][..], Vec::as_slice);
@@ -1658,6 +1719,90 @@ fn atomic_or_tseitin_body(
     atomic_or_tseitin_body_with_extras(body, &[], pool, rules, tseitin)
 }
 
+/// Populate [`ElRules::abox_nominal_reach`]: for each **transitive**
+/// named role `R`, compute the transitive closure of `R` over named
+/// individuals (`ObjectPropertyAssertion`s) and map each source's
+/// `NomKey` to the `NomKey`s of all reachable individuals. Enables the
+/// sound `X ⊑ ∃R.{a}`, `a R⁺ b` ⟹ `X ⊑ ∃R.{b}` propagation in
+/// `process_fact`. No-op unless the ontology has transitive roles with
+/// `ABox` edges.
+fn build_abox_nominal_reach(
+    internal: &InternalOntology,
+    tseitin: &mut TseitinAllocator,
+    rules: &mut ElRules,
+) {
+    use std::collections::BTreeSet;
+    let mut transitive: HashSet<RoleId> = HashSet::new();
+    for ax in &internal.axioms {
+        if let Axiom::TransitiveRole(role) = ax
+            && !role.is_inverse()
+        {
+            transitive.insert(role.role_id());
+        }
+    }
+    if transitive.is_empty() {
+        return;
+    }
+    // Direct R-successor graph over individuals (named, transitive R only).
+    let mut direct: HashMap<RoleId, HashMap<IndividualId, BTreeSet<IndividualId>>> = HashMap::new();
+    for ax in &internal.axioms {
+        if let Axiom::ObjectPropertyAssertion {
+            role,
+            subject,
+            object,
+        } = ax
+            && !role.is_inverse()
+            && transitive.contains(&role.role_id())
+        {
+            direct
+                .entry(role.role_id())
+                .or_default()
+                .entry(*subject)
+                .or_default()
+                .insert(*object);
+        }
+    }
+    for (role, graph) in &direct {
+        // Naive transitive-closure fixpoint (ABoxes here are tiny).
+        let mut closure = graph.clone();
+        let mut changed = true;
+        while changed {
+            changed = false;
+            let sources: Vec<IndividualId> = closure.keys().copied().collect();
+            for a in sources {
+                let mids: Vec<IndividualId> = closure
+                    .get(&a)
+                    .map(|s| s.iter().copied().collect())
+                    .unwrap_or_default();
+                let mut additions: Vec<IndividualId> = Vec::new();
+                for m in mids {
+                    if let Some(ms) = graph.get(&m) {
+                        additions.extend(ms.iter().copied());
+                    }
+                }
+                if let Some(reach) = closure.get_mut(&a) {
+                    for t in additions {
+                        if t != a && reach.insert(t) {
+                            changed = true;
+                        }
+                    }
+                }
+            }
+        }
+        for (a, reach) in &closure {
+            if reach.is_empty() {
+                continue;
+            }
+            let a_key = tseitin.introduce_nominal(*a);
+            let targets: Vec<ClassId> = reach
+                .iter()
+                .map(|&b| tseitin.introduce_nominal(b))
+                .collect();
+            rules.abox_nominal_reach.insert((*role, a_key), targets);
+        }
+    }
+}
+
 /// Return the list of alternative body class ids for an existential
 /// trigger's body. For `Atomic` / `And` returns one element. For
 /// `Or(C1, ..., Cn)` returns one element per operand (each itself
@@ -1701,6 +1846,13 @@ fn atomic_or_tseitin_body_with_extras(
 ) -> Option<ClassId> {
     let body_atomics: Vec<ClassId> = match pool.get(body) {
         ConceptExpr::Atomic(id) => vec![*id],
+        // Nominal `{a}` body (`∃R.{a}`, i.e. ObjectHasValue): use an
+        // opaque per-individual synthetic class as a structural
+        // stand-in so the EL fold of `C ≡ D ⊓ ∃R.{a}` matches the
+        // `X ⊑ ∃R.{a}` fact. Sound (1:1 individual identity); the
+        // singleton/cardinality semantics of `{a}` are deliberately
+        // not modeled (under-approximation — the tableau handles those).
+        ConceptExpr::Nominal(ind) => vec![tseitin.introduce_nominal(*ind)],
         ConceptExpr::And(operands) => {
             atomic_classes_with_existential_markers(operands, pool, rules, tseitin)?
         }
@@ -2599,6 +2751,47 @@ Ontology(<http://rustdl.test/test>\n\
         assert!(subs.contains(class(&internal, "X"), class(&internal, "W")));
     }
 
+    #[test]
+    fn nominal_transitive_abox_fold_classifies() {
+        // Wine region pattern: AlsatianWine ≡ Wine ⊓ ∃locatedIn.{Alsace};
+        // FrenchWine ≡ Wine ⊓ ∃locatedIn.{French}; locatedIn transitive;
+        // ABox Alsace locatedIn French. By transitivity AlsatianWine's
+        // locatedIn-witness reaches French ⟹ AlsatianWine ⊑ FrenchWine.
+        // Exercises the nominal NomKey fold (B) + transitive-ABox
+        // propagation (A). EL alone drops nominal-filler existentials.
+        let internal = parse_internal(&format!(
+            "{HEADER}\
+Ontology(<http://rustdl.test/test>\n\
+    Declaration(Class(:Wine))\n\
+    Declaration(Class(:AlsatianWine))\n\
+    Declaration(Class(:FrenchWine))\n\
+    Declaration(NamedIndividual(:Alsace))\n\
+    Declaration(NamedIndividual(:French))\n\
+    Declaration(ObjectProperty(:locatedIn))\n\
+    TransitiveObjectProperty(:locatedIn)\n\
+    ObjectPropertyAssertion(:locatedIn :Alsace :French)\n\
+    EquivalentClasses(:AlsatianWine ObjectIntersectionOf(:Wine ObjectHasValue(:locatedIn :Alsace)))\n\
+    EquivalentClasses(:FrenchWine ObjectIntersectionOf(:Wine ObjectHasValue(:locatedIn :French)))\n\
+)\n"
+        ));
+        let subs = saturate(&internal);
+        assert!(
+            subs.contains(
+                class(&internal, "AlsatianWine"),
+                class(&internal, "FrenchWine")
+            ),
+            "nominal transitive-ABox fold failed: AlsatianWine ⊑ FrenchWine"
+        );
+        // Soundness: the reverse must NOT hold (French does not locate in Alsace).
+        assert!(
+            !subs.contains(
+                class(&internal, "FrenchWine"),
+                class(&internal, "AlsatianWine")
+            ),
+            "unsound: FrenchWine ⊑ AlsatianWine should not hold"
+        );
+    }
+
     #[test]
     fn out_of_fragment_axioms_dont_panic() {
         let internal = parse_internal(&format!(