rustdl 0.3.25__tar.gz → 0.3.26__tar.gz

{rustdl-0.3.25 → rustdl-0.3.26}/Cargo.lock

@@ -1018,7 +1018,7 @@ checksum = "384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe"
 
 [[package]]
 name = "owl-dl-bench"
-version = "0.3.25"
+version = "0.3.26"
 dependencies = [
  "anyhow",
  "clap",
@@ -1038,7 +1038,7 @@ dependencies = [
 
 [[package]]
 name = "owl-dl-cb"
-version = "0.3.25"
+version = "0.3.26"
 dependencies = [
  "hashbrown 0.15.5",
  "owl-dl-core",
@@ -1046,7 +1046,7 @@ dependencies = [
 
 [[package]]
 name = "owl-dl-cli"
-version = "0.3.25"
+version = "0.3.26"
 dependencies = [
  "anyhow",
  "clap",
@@ -1059,7 +1059,7 @@ dependencies = [
 
 [[package]]
 name = "owl-dl-core"
-version = "0.3.25"
+version = "0.3.26"
 dependencies = [
  "bitvec",
  "bumpalo",
@@ -1073,7 +1073,7 @@ dependencies = [
 
 [[package]]
 name = "owl-dl-datatypes"
-version = "0.3.25"
+version = "0.3.26"
 dependencies = [
  "owl-dl-core",
  "proptest",
@@ -1083,7 +1083,7 @@ dependencies = [
 
 [[package]]
 name = "owl-dl-py"
-version = "0.3.25"
+version = "0.3.26"
 dependencies = [
  "horned-owl",
  "owl-dl-core",
@@ -1094,7 +1094,7 @@ dependencies = [
 
 [[package]]
 name = "owl-dl-reasoner"
-version = "0.3.25"
+version = "0.3.26"
 dependencies = [
  "anyhow",
  "dashmap",
@@ -1112,7 +1112,7 @@ dependencies = [
 
 [[package]]
 name = "owl-dl-saturation"
-version = "0.3.25"
+version = "0.3.26"
 dependencies = [
  "dashmap",
  "fixedbitset",
@@ -1128,7 +1128,7 @@ dependencies = [
 
 [[package]]
 name = "owl-dl-tableau"
-version = "0.3.25"
+version = "0.3.26"
 dependencies = [
  "bitvec",
  "bumpalo",
@@ -2554,7 +2554,7 @@ dependencies = [
 
 [[package]]
 name = "xtask"
-version = "0.3.25"
+version = "0.3.26"
 dependencies = [
  "anyhow",
  "clap",

{rustdl-0.3.25 → rustdl-0.3.26}/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.25"
+version = "0.3.26"
 edition = "2024"
 rust-version = "1.88"
 license = "Apache-2.0 OR MIT"

{rustdl-0.3.25 → rustdl-0.3.26}/PKG-INFO

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

{rustdl-0.3.25 → rustdl-0.3.26}/crates/owl-dl-reasoner/src/classify.rs

@@ -638,7 +638,27 @@ pub(crate) fn classify_internal_with_timeout(
     // RUSTDL_HORN_SHORTCIRCUIT (default ON) for A/B isolation.
     if is_pure_el(internal)
         || (crate::horn_shortcircuit_enabled() && saturator_complete_fragment(internal))
+        || (crate::classify_tbox_fragment_enabled() && tbox_only_saturator_eligible(internal))
     {
+        // Lever 1 admits ABox-bearing ontologies to this fast path, so — like
+        // the top-down path — run the sound ABox-driven inconsistency pre-check
+        // first (nominal-free ABox is irrelevant to subsumption, but an
+        // inconsistent ABox still makes every class unsatisfiable). ABox-free
+        // inputs skip it (has_abox_axioms is a microsecond O(n) scan).
+        if crate::abox_check_enabled() && has_abox_axioms(internal) {
+            let prepared = PreparedOntology::from_internal(internal.clone())?;
+            if let crate::abox_check::AboxVerdict::Inconsistent { reason } = prepared.abox_verdict()
+            {
+                if std::env::var_os("RUSTDL_TRACE").is_some() {
+                    eprintln!("abox_check: inconsistent — {reason:?}");
+                }
+                return Ok(classify_inconsistent(
+                    classes,
+                    index,
+                    analyze_fragment(internal),
+                ));
+            }
+        }
         return Ok(classify_pure_el(internal, &classes, &index, &closure));
     }
 
@@ -893,12 +913,35 @@ fn classify_inconsistent(
 /// expand to cardinality, `ABox` assertions, ...) immediately returns
 /// `false`.
 pub(crate) fn is_pure_el(internal: &InternalOntology) -> bool {
+    is_pure_el_impl(internal, false)
+}
+
+/// Backing check for [`is_pure_el`]. `skip_abox` ⟹ ignore `ABox` assertion
+/// axioms — Lever 1: a nominal-free `ABox` is irrelevant to class subsumption,
+/// so an EL `TBox` carrying a big `ABox` is still classified completely by the
+/// saturation fast path.
+fn is_pure_el_impl(internal: &InternalOntology, skip_abox: bool) -> bool {
     internal
         .axioms
         .iter()
+        .filter(|ax| !(skip_abox && is_abox_axiom(ax)))
         .all(|ax| is_el_axiom(ax, &internal.concepts))
 }
 
+/// True for the five `ABox` assertion axiom forms (individual-level). Used by
+/// Lever 1 ([`tbox_only_saturator_eligible`]) to restrict the fragment gate to
+/// the `TBox`. Kept in sync with [`has_abox_axioms`].
+fn is_abox_axiom(ax: &Axiom) -> bool {
+    matches!(
+        ax,
+        Axiom::ClassAssertion { .. }
+            | Axiom::ObjectPropertyAssertion { .. }
+            | Axiom::NegativeObjectPropertyAssertion { .. }
+            | Axiom::SameIndividual(_)
+            | Axiom::DifferentIndividuals(_)
+    )
+}
+
 fn is_el_axiom(ax: &Axiom, pool: &ConceptPool) -> bool {
     match ax {
         Axiom::SubClassOf { sub, sup } => is_el_concept(*sub, pool) && is_el_concept(*sup, pool),
@@ -935,7 +978,13 @@ fn is_el_axiom(ax: &Axiom, pool: &ConceptPool) -> bool {
 
 fn is_el_concept(c: ConceptId, pool: &ConceptPool) -> bool {
     match pool.get(c) {
-        ConceptExpr::Top | ConceptExpr::Atomic(_) => true,
+        // Bot (Lever 1b): `⊥` is EL — `X ⊑ ⊥` (unsatisfiability) and `A⊓B ⊑ ⊥`
+        // (disjointness) are both reasoned over completely by the saturator's
+        // Bot/disjointness machinery. Sound here because `is_pure_el` admits NO
+        // functional role (is_el_axiom rejects FunctionalRole), so the
+        // disjoint×functional-merge interaction excluded from
+        // `saturator_complete_fragment` cannot arise on this arm.
+        ConceptExpr::Top | ConceptExpr::Atomic(_) | ConceptExpr::Bot => true,
         ConceptExpr::And(ops) => ops.iter().all(|op| is_el_concept(*op, pool)),
         ConceptExpr::Some(role, body) => !role.is_inverse() && is_el_concept(*body, pool),
         _ => false,
@@ -967,6 +1016,15 @@ fn is_el_concept(c: ConceptId, pool: &ConceptPool) -> bool {
 /// chains>2, no inverse) stay on the fast path — verified by
 /// `galen_notgalen_in_saturator_fragment` + the corpus FP/MISSED gate.
 pub(crate) fn saturator_complete_fragment(internal: &InternalOntology) -> bool {
+    saturator_complete_fragment_impl(internal, false)
+}
+
+/// Backing check for [`saturator_complete_fragment`]. `skip_abox` ⟹ evaluate the
+/// fragment allowlist over the `TBox` only (Lever 1). The functional-role /
+/// disjoint-gating prelude is computed over ALL axioms (harmless — `ABox`
+/// assertions declare no role characteristics), so only the final per-axiom
+/// allowlist walk is `TBox`-restricted.
+fn saturator_complete_fragment_impl(internal: &InternalOntology, skip_abox: bool) -> bool {
     // The set of roles for which conversion emitted a derived `∃R.⊤ ⊑ ≤1 R`
     // GCI: `FunctionalRole(r) → r` (FORWARD only — `derive_functional_max_
     // cardinality` does not emit for inverse-functional).
@@ -1007,9 +1065,26 @@ pub(crate) fn saturator_complete_fragment(internal: &InternalOntology) -> bool {
     internal
         .axioms
         .iter()
+        .filter(|ax| !(skip_abox && is_abox_axiom(ax)))
         .all(|ax| is_saturator_axiom(ax, &internal.concepts, &functional_roles, disjoint_ok))
 }
 
+/// Lever 1 eligibility: the ontology has an `ABox`, uses NO nominals, and its
+/// `TBox` (all non-`ABox` axioms) lies in the saturator's complete fragment
+/// (pure-EL, or the EL+functional/hierarchy/chains fragment). When true, the
+/// nominal-free `ABox` is provably irrelevant to class subsumption, so the
+/// ontology can take the saturation-only fast path instead of the O(n²)
+/// per-pair hybrid loop. **Sound by construction** — see
+/// [`crate::classify_tbox_fragment_enabled`]. Env gating is the caller's job
+/// (mirrors [`saturator_complete_fragment`], a pure predicate).
+pub(crate) fn tbox_only_saturator_eligible(internal: &InternalOntology) -> bool {
+    has_abox_axioms(internal)
+        && !crate::ontology_uses_nominals(internal)
+        && (is_pure_el_impl(internal, true)
+            || (crate::horn_shortcircuit_enabled()
+                && saturator_complete_fragment_impl(internal, true)))
+}
+
 /// True iff `c` is exactly the derived functional-enforcement consequent
 /// `≤1 role.⊤` (`Max(1, role, Top)` unqualified) AND `role` carries a matching
 /// functional axiom (so the saturator's bitset enforces it). Used to accept
@@ -1055,6 +1130,17 @@ fn is_saturator_axiom(
         {
             true
         }
+        // Lower-`⊥` GCI (Lever 1b): `X ⊑ ⊥`. A CONJUNCTIVE LHS (`A⊓B ⊑ ⊥`) is a
+        // disjointness assertion — gate on `disjoint_ok` exactly like a native
+        // `DisjointClasses` (the disjoint×functional-merge interaction is
+        // unproven, so it must fall back when a functional role is present). A
+        // non-conjunctive `A ⊑ ⊥` is a plain single-class unsatisfiability with
+        // no such interaction ⇒ always in-fragment. The LHS below `⊥` must still
+        // be a saturator concept.
+        Axiom::SubClassOf { sub, sup } if matches!(pool.get(*sup), ConceptExpr::Bot) => {
+            is_saturator_concept(*sub, pool)
+                && (disjoint_ok || !matches!(pool.get(*sub), ConceptExpr::And(_)))
+        }
         Axiom::SubClassOf { sub, sup } => {
             is_saturator_concept(*sub, pool) && is_saturator_concept(*sup, pool)
         }
@@ -1174,7 +1260,7 @@ pub fn classify_top_down_with_timeout<A: ForIRI>(
 
 /// Returns true iff the ontology contains any `ABox` axiom. Cheap
 /// scan over `internal.axioms` used to skip the `ABox` consistency
-/// pre-check entirely on TBox-only inputs (e.g. GALEN), where
+/// pre-check entirely on `TBox`-only inputs (e.g. GALEN), where
 /// building `PreparedOntology` solely to consult `abox_verdict()`
 /// is wasted work — the check would early-return `Unknown` on
 /// empty `individuals` anyway. Microseconds even on the largest
@@ -1294,6 +1380,7 @@ pub(crate) fn classify_top_down_internal(
     // RUSTDL_HORN_SHORTCIRCUIT.
     if is_pure_el(internal)
         || (crate::horn_shortcircuit_enabled() && saturator_complete_fragment(internal))
+        || (crate::classify_tbox_fragment_enabled() && tbox_only_saturator_eligible(internal))
     {
         // Skip the ABox check entirely on ABox-free inputs — building
         // PreparedOntology costs ~1.5 s on GALEN-sized TBoxes (NNF +
@@ -3686,6 +3773,134 @@ Ontology(<http://rustdl.test/test>\n\
         );
     }
 
+    #[test]
+    fn tbox_fragment_accepts_el_tbox_with_abox() {
+        // Lever 1: an EL TBox (A ⊑ B) carrying a nominal-free ABox must be
+        // eligible for the saturation fast path — the ABox is irrelevant to
+        // class subsumption. Without Lever 1 the ClassAssertion kicks it to the
+        // O(n²) hybrid loop (the ORE ore_ont_1043 DNF shape).
+        let i = internal_of(
+            "    Declaration(Class(:A))\n\
+    Declaration(Class(:B))\n\
+    Declaration(NamedIndividual(:x))\n\
+    SubClassOf(:A :B)\n\
+    ClassAssertion(:A :x)\n",
+        );
+        assert!(
+            !is_pure_el(&i),
+            "sanity: the full-axiom gate rejects it (ABox present)"
+        );
+        assert!(
+            tbox_only_saturator_eligible(&i),
+            "EL TBox + nominal-free ABox must be Lever-1 fast-path eligible"
+        );
+    }
+
+    #[test]
+    fn tbox_fragment_rejects_nominal_abox() {
+        // A nominal in the TBox (ObjectHasValue → ConceptExpr::Nominal) makes
+        // the ABox subsumption-relevant, so Lever 1 must NOT fire.
+        let i = internal_of(
+            "    Declaration(Class(:A))\n\
+    Declaration(Class(:B))\n\
+    Declaration(ObjectProperty(:r))\n\
+    Declaration(NamedIndividual(:x))\n\
+    SubClassOf(:A ObjectHasValue(:r :x))\n\
+    ClassAssertion(:A :x)\n",
+        );
+        assert!(
+            !tbox_only_saturator_eligible(&i),
+            "an ontology using nominals must be excluded from Lever 1"
+        );
+    }
+
+    #[test]
+    fn tbox_fragment_rejects_forall_tbox() {
+        // Out-of-fragment TBox (∀) must reject even with the ABox stripped —
+        // the D10 unsound-completeness guard carries into the TBox-only view.
+        let i = internal_of(
+            "    Declaration(Class(:A))\n\
+    Declaration(Class(:B))\n\
+    Declaration(ObjectProperty(:r))\n\
+    Declaration(NamedIndividual(:x))\n\
+    SubClassOf(:A ObjectAllValuesFrom(:r :B))\n\
+    ClassAssertion(:A :x)\n",
+        );
+        assert!(
+            !tbox_only_saturator_eligible(&i),
+            "a ∀ in the TBox must reject even under the TBox-only view"
+        );
+    }
+
+    #[test]
+    fn bot_lowered_disjointness_is_pure_el() {
+        // Lever 1b: an explicit `A ⊓ B ⊑ ⊥` (SubClassOf(And, owl:Nothing)) is a
+        // sound EL disjointness/unsat the saturator handles completely. With no
+        // functional role it must be in the pure-EL fast path. RED before Bot ∈
+        // is_el_concept.
+        let i = internal_of(
+            "    Declaration(Class(:A))\n\
+    Declaration(Class(:B))\n\
+    SubClassOf(:A :B)\n\
+    SubClassOf(ObjectIntersectionOf(:A :B) owl:Nothing)\n",
+        );
+        assert!(
+            is_pure_el(&i),
+            "EL + `A⊓B⊑⊥` (no functional) must be pure-EL fast-path eligible"
+        );
+    }
+
+    #[test]
+    fn saturator_fragment_accepts_atomic_unsat() {
+        // A plain `A ⊑ ⊥` (single-class unsatisfiability) carries no
+        // functional-merge interaction, so it stays in-fragment even with a
+        // functional role present.
+        let i = internal_of(
+            "    Declaration(Class(:A))\n\
+    Declaration(ObjectProperty(:r))\n\
+    FunctionalObjectProperty(:r)\n\
+    SubClassOf(:A owl:Nothing)\n",
+        );
+        assert!(
+            saturator_complete_fragment(&i),
+            "atomic `A⊑⊥` + functional must stay in the saturator fragment"
+        );
+    }
+
+    #[test]
+    fn saturator_fragment_rejects_conjunctive_bot_with_functional() {
+        // FP-CRITICAL: `A⊓B⊑⊥` is disjointness(A,B); combined with a functional
+        // role it is the UNPROVEN disjoint×functional-merge interaction the gate
+        // deliberately excludes. It must fall back to the hybrid path (same
+        // policy as a native DisjointClasses + functional).
+        let i = internal_of(
+            "    Declaration(Class(:A))\n\
+    Declaration(Class(:B))\n\
+    Declaration(ObjectProperty(:r))\n\
+    FunctionalObjectProperty(:r)\n\
+    SubClassOf(ObjectIntersectionOf(:A :B) owl:Nothing)\n",
+        );
+        assert!(
+            !saturator_complete_fragment(&i),
+            "conjunctive `A⊓B⊑⊥` + functional (disjoint×functional) must fall back"
+        );
+    }
+
+    #[test]
+    fn tbox_fragment_inert_without_abox() {
+        // No ABox ⇒ Lever 1 is inert (the ordinary gate already decides). Guards
+        // against changing ABox-free classification behaviour.
+        let i = internal_of(
+            "    Declaration(Class(:A))\n\
+    Declaration(Class(:B))\n\
+    SubClassOf(:A :B)\n",
+        );
+        assert!(
+            !tbox_only_saturator_eligible(&i),
+            "no ABox ⇒ Lever 1 must be inert"
+        );
+    }
+
     #[test]
     fn saturator_fragment_rejects_disjoint_union() {
         // DisjointUnion carries a disjunctive covering (class ≡ ⊔members), which

{rustdl-0.3.25 → rustdl-0.3.26}/crates/owl-dl-reasoner/src/lib.rs

@@ -2923,12 +2923,30 @@ pub fn classify_tbox_only_enabled() -> bool {
     std::env::var_os("RUSTDL_CLASSIFY_TBOX_ONLY").is_none_or(|v| v != "0" && !v.is_empty())
 }
 
+/// Lever 1 (2026-07-20): when the ontology is nominal-free, evaluate the
+/// Horn-shortcircuit FRAGMENT gate on the `TBox` axioms only, ignoring the `ABox`.
+/// An EL/saturator-fragment `TBox` carrying a large `ABox` is otherwise kicked off
+/// the saturation fast path (`ABox` assertions fail the fragment allowlist) into
+/// the O(n²) per-pair hybrid loop, which DNFs on 8k–70k-class ontologies even
+/// though the saturation closure is already complete (verified == Konclude on
+/// the ORE ChEBI/OBO tier). **Sound by construction:** the existing fragment
+/// guarantee applies to the `TBox`; a nominal-free `ABox` cannot contribute a class
+/// subsumption (monotone, same basis as [`classify_tbox_only_enabled`]); and the
+/// inconsistent-`ABox` → all-unsat verdict is still produced by the `abox_check`
+/// pre-check that runs on the fast-path arm when `has_abox_axioms`. Recovers ~67
+/// ORE onts (e.g. `ore_ont_1043`: DNF → ~7 s, closure == Konclude).
+/// `RUSTDL_CLASSIFY_TBOX_FRAGMENT=0` reverts to the full-axiom fragment gate.
+#[must_use]
+pub fn classify_tbox_fragment_enabled() -> bool {
+    std::env::var_os("RUSTDL_CLASSIFY_TBOX_FRAGMENT").is_none_or(|v| v != "0" && !v.is_empty())
+}
+
 /// True iff any axiom's class expression references a nominal (`ObjectOneOf` /
 /// `ObjectHasValue`, both lowered to `ConceptExpr::Nominal`). When false, the
 /// `ABox` is provably irrelevant to class subsumption, enabling Lever A. Scanned
 /// once at `from_internal` time over the un-mutated axioms (nominals only occur
 /// inside class expressions, so only concept-bearing axioms are walked).
-fn ontology_uses_nominals(internal: &InternalOntology) -> bool {
+pub(crate) fn ontology_uses_nominals(internal: &InternalOntology) -> bool {
     fn has_nominal(c: ConceptId, pool: &ConceptPool) -> bool {
         match pool.get(c) {
             ConceptExpr::Nominal(_) => true,