Struct AbsorbedTBox 

pub struct AbsorbedTBox {
    pub concept_rules: Vec<ConceptRule>,
    pub nominal_rules: Vec<NominalRule>,
    pub role_rules: Vec<RoleRule>,
    pub residual_gcis: Vec<ConceptId>,
    pub deferred_or_residuals: Vec<ConceptId>,
    pub concept_rules_by_trigger: HashMap<ClassId, Vec<ConceptId>>,
    pub nominal_rules_by_individual: HashMap<IndividualId, Vec<ConceptId>>,
    pub unguarded_role_rules: Vec<RoleRule>,
    pub guarded_role_rules_by_guard: HashMap<ClassId, Vec<RoleRule>>,
}

The output of absorption. Always a derived view of an InternalOntology’s axiom list — never a replacement.

In addition to the four Vec-based axiom families, holds two dispatch indices (Self::concept_rules_by_trigger, Self::nominal_rules_by_individual). They map a trigger to the list of conclusions to apply, so crate::AbsorbedTBox-driven tableau rules do O(triggers × hits_per_trigger) work per node instead of O(triggers × |rules|). absorb and absorb_roles keep the indices in sync; callers who build an AbsorbedTBox by hand should call Self::finalize before handing it to the tableau (the tableau falls back to a linear scan when the indices are empty, so this is “for performance, not correctness”).

Fields

concept_rules: Vec<ConceptRule>

A ⊑ ψ — when the trigger class appears in a node label, add the conclusion concept.

nominal_rules: Vec<NominalRule>

{a} ⊑ ψ — apply the conclusion directly to the named individual.

role_rules: Vec<RoleRule>

[guard ⊑] ∀R.D — when an R-edge to y is added (from a node carrying the guard if Some, or any node if None), add target_label to y’s label.

residual_gcis: Vec<ConceptId>

⊤ ⊑ φ — applied universally by the tableau, after every other pattern was tried.

deferred_or_residuals: Vec<ConceptId>

Subset of Self::residual_gcis whose body is Or(_) — the lazy-unfolding deferral candidates (see docs/lazy-unfolding-plan.md). apply_residual_gcis skips these (they’re not materialised on every node eagerly); apply_deferred_or_residuals materialises them at saturate stable-state, but only on nodes where no disjunct is already present. Populated by Self::finalize.

concept_rules_by_trigger: HashMap<ClassId, Vec<ConceptId>>

Index: every conclusion ConceptId that should fire for a given trigger class. Derived from concept_rules by Self::finalize; consulted by apply_concept_rules to skip the linear scan.

nominal_rules_by_individual: HashMap<IndividualId, Vec<ConceptId>>

Same idea for nominal rules — index by individual id.

unguarded_role_rules: Vec<RoleRule>

RoleRules with no class guard — they fire on any node that has an outgoing edge matching their role. Partition of role_rules produced by Self::finalize.

guarded_role_rules_by_guard: HashMap<ClassId, Vec<RoleRule>>

Guarded RoleRules indexed by guard class. Partition of role_rules produced by Self::finalize.

Implementations

impl AbsorbedTBox

pub fn finalize(&mut self)

Rebuild the dispatch indices from the canonical Vec fields. Idempotent — safe to call after any mutation of the rule lists. Linear in the total rule count; cheap.

Trait Implementations

impl Clone for AbsorbedTBox

fn clone(&self) -> AbsorbedTBox

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for AbsorbedTBox

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for AbsorbedTBox

fn default() -> AbsorbedTBox

Returns the “default value” for a type.

impl Eq for AbsorbedTBox

impl PartialEq for AbsorbedTBox

fn eq(&self, other: &AbsorbedTBox) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for AbsorbedTBox