rustdl 0.3.24__tar.gz → 0.3.26__tar.gz

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

@@ -1018,7 +1018,7 @@ checksum = "384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe"
 
 [[package]]
 name = "owl-dl-bench"
-version = "0.3.24"
+version = "0.3.26"
 dependencies = [
  "anyhow",
  "clap",
@@ -1038,7 +1038,7 @@ dependencies = [
 
 [[package]]
 name = "owl-dl-cb"
-version = "0.3.24"
+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.24"
+version = "0.3.26"
 dependencies = [
  "anyhow",
  "clap",
@@ -1059,7 +1059,7 @@ dependencies = [
 
 [[package]]
 name = "owl-dl-core"
-version = "0.3.24"
+version = "0.3.26"
 dependencies = [
  "bitvec",
  "bumpalo",
@@ -1073,7 +1073,7 @@ dependencies = [
 
 [[package]]
 name = "owl-dl-datatypes"
-version = "0.3.24"
+version = "0.3.26"
 dependencies = [
  "owl-dl-core",
  "proptest",
@@ -1083,7 +1083,7 @@ dependencies = [
 
 [[package]]
 name = "owl-dl-py"
-version = "0.3.24"
+version = "0.3.26"
 dependencies = [
  "horned-owl",
  "owl-dl-core",
@@ -1094,7 +1094,7 @@ dependencies = [
 
 [[package]]
 name = "owl-dl-reasoner"
-version = "0.3.24"
+version = "0.3.26"
 dependencies = [
  "anyhow",
  "dashmap",
@@ -1112,7 +1112,7 @@ dependencies = [
 
 [[package]]
 name = "owl-dl-saturation"
-version = "0.3.24"
+version = "0.3.26"
 dependencies = [
  "dashmap",
  "fixedbitset",
@@ -1128,7 +1128,7 @@ dependencies = [
 
 [[package]]
 name = "owl-dl-tableau"
-version = "0.3.24"
+version = "0.3.26"
 dependencies = [
  "bitvec",
  "bumpalo",
@@ -2554,7 +2554,7 @@ dependencies = [
 
 [[package]]
 name = "xtask"
-version = "0.3.24"
+version = "0.3.26"
 dependencies = [
  "anyhow",
  "clap",

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

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

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

{rustdl-0.3.24 → 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));
     }
 
@@ -674,11 +694,11 @@ pub(crate) fn classify_internal_with_timeout(
                 // assuming sat here can never cause us to claim a
                 // false subsumption later.
                 let sat = prepared
-                    .decide_with_deadline(deadline, move |pool| pool.atomic(class_id))?
+                    .decide_classify_with_deadline(deadline, move |pool| pool.atomic(class_id))?
                     .unwrap_or(true);
                 Ok((i, sat, false))
             } else {
-                let sat = prepared.decide(move |pool| pool.atomic(class_id))?;
+                let sat = prepared.decide_classify(move |pool| pool.atomic(class_id))?;
                 Ok((i, sat, false))
             }
         })
@@ -739,7 +759,7 @@ pub(crate) fn classify_internal_with_timeout(
             };
             match per_pair_timeout {
                 None => {
-                    let sat = prepared.decide(build)?;
+                    let sat = prepared.decide_classify(build)?;
                     Ok((i, j, !sat, false, false))
                 }
                 Some(timeout) => {
@@ -749,7 +769,7 @@ pub(crate) fn classify_internal_with_timeout(
                     // extra threads, no cancellation race — the rayon
                     // worker stays bound to this single decide call.
                     let deadline = Instant::now() + timeout;
-                    match prepared.decide_with_deadline(deadline, build)? {
+                    match prepared.decide_classify_with_deadline(deadline, build)? {
                         Some(sat) => Ok((i, j, !sat, false, false)),
                         None => Ok((i, j, false, false, true)),
                     }
@@ -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 +
@@ -1455,7 +1542,7 @@ pub(crate) fn classify_top_down_internal(
                 // sound under-approximation. Crashing classify on a
                 // single oversized class is worse.
                 let sat = match prepared
-                    .decide_with_deadline(deadline, move |pool| pool.atomic(class_id))
+                    .decide_classify_with_deadline(deadline, move |pool| pool.atomic(class_id))
                 {
                     Ok(Some(s)) => s,
                     Ok(None) | Err(crate::ReasonError::NoVerdict) => true,
@@ -1463,7 +1550,7 @@ pub(crate) fn classify_top_down_internal(
                 };
                 Ok((i, sat, false))
             } else {
-                let sat = prepared.decide(move |pool| pool.atomic(class_id))?;
+                let sat = prepared.decide_classify(move |pool| pool.atomic(class_id))?;
                 Ok((i, sat, false))
             }
         })
@@ -2464,7 +2551,7 @@ fn subsumes_via_tableau(
     // tableau probe even when per_pair_timeout is None (global-only mode).
     match effective_deadline(global_deadline, per_pair_timeout) {
         None => {
-            let sat = prepared.decide(build)?;
+            let sat = prepared.decide_classify(build)?;
             stats.tableau_subsumption_calls += 1;
             let subsumed = !sat;
             if was_fast_refuted && subsumed {
@@ -2483,7 +2570,7 @@ fn subsumes_via_tableau(
             // (sound under-approximation), counted in `timed_out_pairs`.
             // Crashing classify on a single oversized pair is worse
             // than under-reporting the subsumption.
-            match prepared.decide_with_deadline(deadline, build) {
+            match prepared.decide_classify_with_deadline(deadline, build) {
                 Ok(Some(sat)) => {
                     stats.tableau_subsumption_calls += 1;
                     let subsumed = !sat;
@@ -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.24 → rustdl-0.3.26}/crates/owl-dl-reasoner/src/lib.rs

@@ -2908,6 +2908,71 @@ pub fn wedge_consistency_enabled() -> bool {
     std::env::var_os("RUSTDL_WEDGE_CONSISTENCY").is_none_or(|v| v != "0" && !v.is_empty())
 }
 
+/// Lever A (2026-07-20): when the ontology uses NO nominals, the `ABox` is
+/// irrelevant to class subsumption, so the per-pair classification tableau
+/// probes do NOT seed it. This eliminates the `ABox`-driven completion-graph
+/// blow-up that stalls near-EL `ABox`-bearing ontologies (e.g. ORE
+/// `ore_ont_10894`: DNF → ~1.6 s, closure byte-identical to saturation/Konclude).
+/// **Sound:** absent nominals the `ABox` cannot affect `C ⊑ D`; a
+/// globally-inconsistent `ABox` is still caught by the separate
+/// `abox_check`/`abox_saturation` pre-checks (so this is FP=0 by construction —
+/// a missed inconsistency would be a MISS, gated by the corpus MISSED=0 check).
+/// `RUSTDL_CLASSIFY_TBOX_ONLY=0` reverts to seeding the full `ABox`.
+#[must_use]
+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).
+pub(crate) fn ontology_uses_nominals(internal: &InternalOntology) -> bool {
+    fn has_nominal(c: ConceptId, pool: &ConceptPool) -> bool {
+        match pool.get(c) {
+            ConceptExpr::Nominal(_) => true,
+            ConceptExpr::Not(x)
+            | ConceptExpr::Some(_, x)
+            | ConceptExpr::All(_, x)
+            | ConceptExpr::Min(_, _, x)
+            | ConceptExpr::Max(_, _, x) => has_nominal(*x, pool),
+            ConceptExpr::And(ops) | ConceptExpr::Or(ops) => {
+                ops.iter().any(|op| has_nominal(*op, pool))
+            }
+            _ => false,
+        }
+    }
+    let pool = &internal.concepts;
+    internal.axioms.iter().any(|ax| match ax {
+        Axiom::SubClassOf { sub, sup } => has_nominal(*sub, pool) || has_nominal(*sup, pool),
+        Axiom::EquivalentClasses(v) | Axiom::DisjointClasses(v) => {
+            v.iter().any(|c| has_nominal(*c, pool))
+        }
+        Axiom::DisjointUnion { members, .. } => members.iter().any(|c| has_nominal(*c, pool)),
+        Axiom::ClassAssertion { class, .. } => has_nominal(*class, pool),
+        _ => false,
+    })
+}
+
 /// Bounded wall budget (ms) for the main-tableau `decide(Top)`
 /// fall-through used when the consistency wedge returns `Stalled`. The
 /// whole point of the wedge route is to kill the unbounded
@@ -3966,6 +4031,13 @@ pub(crate) struct PreparedOntology {
     disjoint_role_pairs: Vec<(RoleId, RoleId)>,
     complements: Vec<(ConceptId, ConceptId)>,
     pub(crate) abox: Abox,
+    /// Lever A (2026-07-20): true iff the `ABox` is provably irrelevant to class
+    /// subsumption — the ontology has `ABox` axioms, uses NO nominals, and the
+    /// `TBox`-only-classify gate is on. When true, the per-pair classification
+    /// tableau probes (`decide_classify`) do NOT seed the `ABox`, avoiding the
+    /// completion-graph blow-up it causes on near-EL `ABox`-bearing ontologies.
+    /// `abox` is still kept full for `realize`/`materialize`/consistency.
+    abox_irrelevant_to_classify: bool,
     /// EL saturator closure over the un-mutated input ontology.
     /// Used by [`abox_check`] (P1 `is_unsatisfiable`, P2 `subsumers_of`).
     /// Computed once at build time; classify already computes the same
@@ -4237,6 +4309,11 @@ impl PreparedOntology {
     /// `decide` calls only have to allocate a fresh tableau and run
     /// the search.
     pub(crate) fn from_internal(mut internal: InternalOntology) -> Result<Self, ReasonError> {
+        // Lever A: decide up front (on the un-mutated input) whether the ABox is
+        // irrelevant to class subsumption — has-ABox, no nominals, gate on.
+        let abox_irrelevant_to_classify = classify_tbox_only_enabled()
+            && internal_has_abox(&internal)
+            && !ontology_uses_nominals(&internal);
         // Phase A1 (ABox consistency check): EL closure over the
         // un-mutated input. Used by abox_check for P1 (is_unsatisfiable)
         // and P2 (subsumers_of). Cheap on small ABox-bearing ontologies;
@@ -4320,6 +4397,7 @@ impl PreparedOntology {
             disjoint_role_pairs,
             complements,
             abox,
+            abox_irrelevant_to_classify,
             closure,
             told,
             axioms,
@@ -4471,6 +4549,39 @@ impl PreparedOntology {
         .map(|opt| opt.expect("no deadline ⇒ search always returns Some(_)"))
     }
 
+    /// Lever A: like [`Self::decide`], but for the **classification pairwise
+    /// subsumption loop only** — skips the `ABox` seed when it is provably
+    /// irrelevant to class subsumption (`abox_irrelevant_to_classify`: has
+    /// `ABox`, no nominals, gate on). MUST NOT be used for realize / consistency
+    /// / instance queries, which genuinely need the `ABox`. Global `ABox`
+    /// inconsistency is caught by the separate pre-checks before this loop runs.
+    pub(crate) fn decide_classify<F>(&self, build_test_concept: F) -> Result<bool, ReasonError>
+    where
+        F: FnOnce(&mut ConceptPool) -> ConceptId,
+    {
+        let empty = Abox::default();
+        let abox = if self.abox_irrelevant_to_classify {
+            &empty
+        } else {
+            &self.abox
+        };
+        decide(
+            &self.pool,
+            &self.tbox,
+            &self.hierarchy,
+            &self.inverse_pairs,
+            &self.chain_axioms,
+            &self.asymmetric_roles,
+            &self.disjoint_role_pairs,
+            &self.complements,
+            abox,
+            &self.dkey_ranges,
+            None,
+            build_test_concept,
+        )
+        .map(|opt| opt.expect("no deadline ⇒ search always returns Some(_)"))
+    }
+
     /// Like [`Self::decide`] but the search is bounded by `deadline`.
     /// Returns `Ok(Some(sat))` if the tableau reached a verdict in
     /// time, or `Ok(None)` if the deadline elapsed first.
@@ -4497,6 +4608,40 @@ impl PreparedOntology {
             build_test_concept,
         )
     }
+
+    /// Lever A: like [`Self::decide_with_deadline`], but for the classification
+    /// pairwise subsumption loop only — skips the `ABox` seed when it is provably
+    /// irrelevant (`abox_irrelevant_to_classify`). Same scoping caveat as
+    /// [`Self::decide_classify`].
+    pub(crate) fn decide_classify_with_deadline<F>(
+        &self,
+        deadline: std::time::Instant,
+        build_test_concept: F,
+    ) -> Result<Option<bool>, ReasonError>
+    where
+        F: FnOnce(&mut ConceptPool) -> ConceptId,
+    {
+        let empty = Abox::default();
+        let abox = if self.abox_irrelevant_to_classify {
+            &empty
+        } else {
+            &self.abox
+        };
+        decide(
+            &self.pool,
+            &self.tbox,
+            &self.hierarchy,
+            &self.inverse_pairs,
+            &self.chain_axioms,
+            &self.asymmetric_roles,
+            &self.disjoint_role_pairs,
+            &self.complements,
+            abox,
+            &self.dkey_ranges,
+            Some(deadline),
+            build_test_concept,
+        )
+    }
 }
 
 /// Pre-resolved `ABox` state, ready to seed into the tableau context.