Description Logic

Atomic concepts (unary predicates) are combined using logical operators to define complex classes. Key constructors include:

• Intersection (⊓): Defines a class as the conjunction of others (e.g., Father ⊓ Engineer).
• Union (⊔): Defines a class as the disjunction of others (e.g., Doctor ⊔ Lawyer).
• Complement (¬): Defines the class of all individuals not belonging to a specific concept.
• Existential Restriction (∃): Defines a class of individuals related via a specific role to at least one instance of another concept (e.g., ∃hasChild.Person).
• Universal Restriction (∀): Defines a class of individuals where all role-fillers must belong to a specific concept (e.g., ∀hasChild.Doctor).

Roles (binary predicates) represent relationships between individuals. While less expressive in basic DLs, advanced variants allow role manipulation:

• Atomic Roles: Simple relationships like hasPart or locatedIn.
• Inverse Roles (R⁻): Allows traversal of a relationship in the opposite direction (e.g., hasParent is the inverse of hasChild).
• Role Hierarchies (⊑): Defines sub-properties, such as hasMother ⊑ hasParent.
• Transitive Roles: Declares that if R(a,b) and R(b,c) hold, then R(a,c) must also hold, critical for modeling part-whole relations.

The TBox defines the intensional knowledge or schema of the domain. It contains axioms that constrain the interpretation of concepts and roles:

• Equivalence (≡): States that two concepts have exactly the same instances (e.g., Father ≡ Man ⊓ ∃hasChild.Person).
• Subsumption (⊑): Defines a necessary condition or a parent-child hierarchy (e.g., Professor ⊑ Faculty).
• Disjointness: Declares that two classes cannot share any instances (e.g., Plant ⊑ ¬Animal). The TBox is the primary target for classification and satisfiability reasoning.

The ABox contains extensional knowledge—specific facts about named individuals in the domain. It populates the schema defined by the TBox:

• Concept Assertions: Declares an individual is a member of a class (e.g., Professor(marie_curie)).
• Role Assertions: Declares a relationship between two individuals (e.g., hasChild(marie_curie, irene)).
• Equality/Inequality: States that two names refer to the same or different entities. ABox reasoning involves instance checking and retrieval to find all individuals satisfying a query.

A defining feature of DLs is their guarantee of decidability—algorithms will always terminate with a correct yes/no answer. This is achieved by restricting expressivity to avoid undecidable constructs. The trade-off is defined by complexity classes:

• ALC: The basic Attributive Language with Complement is EXPTIME-complete for satisfiability.
• EL++: A lightweight profile optimized for polynomial-time reasoning (PTIME), widely used in biomedical ontologies like SNOMED CT.
• SROIQ(D): The highly expressive logic underlying OWL 2 DL, with N2EXPTIME-complete worst-case complexity, though highly optimized reasoners perform well in practice.

DL reasoners provide standard inference services that derive implicit knowledge from explicit axioms:

• Satisfiability: Checks if a concept can possibly have any instances without causing a logical contradiction.
• Classification: Computes the complete subsumption hierarchy, placing a new concept automatically under its most specific parents.
• Realization: Finds the most specific concepts an individual belongs to.
• Instance Checking: Verifies if a specific individual is a member of a given concept. These services are the engine behind ontology debugging and query answering.

The schema-level component of a knowledge base that defines the intensional structure of an ontology. The TBox contains class definitions, property restrictions, and axioms that specify how concepts relate to one another.

• Defines concepts like Father ≡ Man ⊓ ∃hasChild.Person
• Establishes subsumption hierarchies (e.g., Mother ⊑ Parent)
• Reasoning tasks include classification and satisfiability checking
• Remains relatively static compared to instance data

The instance-level component containing factual assertions about specific individuals that populate the TBox schema. The ABox grounds abstract definitions in concrete data.

• Contains membership assertions like Mother(MARY)
• Stores relationship assertions like hasChild(JOHN, MARY)
• Reasoning tasks include instance checking and query answering
• Grows dynamically as new facts are ingested

A W3C-standardized computational language built on description logics, designed to represent rich knowledge about entities and their relationships. OWL enables automated reasoning over ontologies.

• OWL 2 DL maps directly to the SROIQ(D) description logic
• Supports property chains, qualified cardinality restrictions, and datatypes
• Profiles like OWL 2 EL trade expressivity for polynomial-time reasoning
• Forms the semantic backbone of the Linked Data ecosystem

The forward-chaining inference process that computes and explicitly stores all implicit logical consequences of an ontology. Materialization pre-calculates the deductive closure for efficient query-time retrieval.

• Applies entailment rules iteratively until a fixpoint is reached
• Transforms complex reasoning into simple lookup operations
• Critical for Ontology-Based Data Access (OBDA) architectures
• Trades storage overhead for dramatic query performance gains

A query answering regime that evaluates SPARQL queries against the full logical closure of an RDF graph, not just explicitly asserted triples. This ensures answers reflect all inferred knowledge.

• Supports entailment regimes like RDFS, OWL Direct Semantics, and RIF
• Enables queries to return results derived from class hierarchies and property chains
• Requires a reasoner to compute the deductive closure at query time or via materialization
• Defined by the W3C SPARQL 1.1 Entailment Regimes specification

A W3C submission combining OWL with Horn-like rules to express conditional logic beyond description logic expressivity. SWRL enables the deduction of relationships that DL constructors alone cannot capture.

• Rules take the form: antecedent → consequent
• Can express role composition across arbitrary-length chains
• Extends reasoning to capture business rules and domain heuristics
• Requires careful use to avoid undecidability when combined with OWL DL