🤖 AI

A General Sufficient Condition for Rewriting Horn-ALCHI Atomic Queries into GQL

This paper introduces DL automata to identify a broad class of Horn-ALCHI ontology-mediated atomic queries that can be rewritten into unions of conjunctive two-way regular path queries (UC2RPQs), a central fragment of the new ISO standard GQL, by employing state stratification to eliminate complexity-raising cyclic dependencies.

Original authors: David Carral, Calixte Gruson, Quentin Manière

Published 2026-08-06

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: David Carral, Calixte Gruson, Quentin Manière

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to find a specific friend in a massive, ever-changing city. You have a map (the database) showing where people are right now, but you also have a set of "rules of the city" (the ontology) that tell you things the map doesn't show directly. For example, the rules might say, "If someone is standing next to a gate, they are also standing next to a link," or "If you are a trusted user, you must be connected to a sensitive node." In the world of computer science, this is called Ontology-Mediated Querying. It's like asking a librarian not just for books on the shelf, but for books that must exist based on the library's cataloging rules.

The challenge arises when these rules get complicated. Sometimes, figuring out if a fact is true requires following a long, winding chain of logic that loops back on itself, like a maze. Traditional database tools are great at simple lookups, but they often get stuck or crash when faced with these complex, looping rules. Enter GQL (Graph Query Language), a new, powerful standard for asking questions about networks. It's like upgrading from a simple paper map to a GPS that can handle complex routes and "what-if" scenarios. The big question scientists have been asking is: Can we translate these tricky, looping rules into GQL so that standard database tools can solve them?

This paper, titled "A General Sufficient Condition for Rewriting Horn-ALCHI Atomic Queries into GQL," tackles that exact puzzle. The authors, David Carral, Calixte Gruson, and Quentin Manière, focus on a specific, powerful type of rule system called Horn-ALCHI. Think of this as a very expressive language for describing how things in a network relate to one another. While this language is great for describing complex worlds, it's notoriously difficult to translate into standard database queries because it allows for "infinite loops" of logic that traditional tools can't handle.

The authors' main discovery is a "magic key" or a specific condition that tells us exactly when these complex rules can be safely translated into GQL. They introduce a new tool called a DL automaton. Imagine this as a tiny, digital robot that walks through your data. Instead of trying to solve the whole puzzle at once, the robot follows a set of instructions (transitions) to see if it can reach a "winning state." If the robot can find a path to the winner, the answer to your query is "yes."

The clever part of their work is identifying a specific type of robot that is guaranteed to work. They call these stratified automata. To understand "stratified," imagine a multi-story building. In a normal building, you might have an elevator that goes from the 10th floor to the 1st, then back to the 10th, creating a confusing loop. A "stratified" building, however, is designed so that you can only move up or stay on the same floor; you can never go back down to a floor you've already visited in a way that creates a confusing cycle. The authors prove that if their robot (the automaton) is built like this "stratified" building—meaning its logic doesn't get stuck in certain kinds of circular dependencies—then it can be perfectly translated into a GQL query.

They show that this condition is broad enough to cover many real-world scenarios that previous methods missed. For instance, they demonstrate that a query about "Trusted Users" in a computer network (which involves checking for links to sensitive nodes and gateways) fits this "stratified" pattern and can be rewritten into GQL. However, they also implicitly rule out the idea that all Horn-ALCHI queries can be rewritten; if the logic creates a specific type of loop that violates the "stratified" building rules, the translation fails.

The paper doesn't just guess; it provides a rigorous mathematical proof. They show step-by-step how to take a complex Horn-ALCHI rule set, turn it into a DL automaton, check if it's stratified, and if so, convert it into a GQL query. They also prove that their method covers more ground than previous attempts, including some complex cases that other researchers had deemed untranslatable. While they don't claim to have solved every possible case (some loops are still too tangled), they have provided a solid, provable method for a large and useful class of problems, opening the door for complex semantic web queries to run on modern graph databases.

Technical Summary: A General Sufficient Condition for Rewriting Horn-ALCHI Atomic Queries into GQL

Problem Statement
The emergence of the ISO standard GQL (Graph Query Language) introduces a powerful query language that extends first-order logic (FO) with controlled regular recursion. This raises a critical question regarding Ontology-Mediated Query (OMQ) answering: which rule queries, defined over expressive Description Logics (DLs), can be rewritten into GQL?

The authors focus on Horn-ALCHI, an expressive DL that supports inverse roles and role constructors. Unlike the DL-Lite family, Horn-ALCHI is generally not first-order rewritable, meaning standard SQL-based evaluation techniques are insufficient. While GQL offers the necessary expressive power (specifically through Unions of Conjunctive Two-Way Regular Path Queries, or UC2RPQs), it remains unclear which Horn-ALCHI queries can be effectively translated into this fragment. The paper addresses the gap in identifying a broad, decidable class of Horn-ALCHI OMQs that admit such rewriting.

Methodology
The authors propose a multi-stage, equivalence-preserving transformation pipeline:

Normalization to Horn-ALC $\not\exists$ :
The process begins by transforming a Horn-ALCHI query into an equivalent Horn-ALC $\not\exists$ query. This involves:
- Eliminating role inclusion axioms (e.g., $R \sqsubseteq S$ ) and inverse role axioms by propagating constraints through the reflexive-transitive closure of role inclusions.
- Eliminating existential quantification in rule heads (e.g., $A \sqsubseteq \exists R.B$ ) by translating them into Datalog rules, following established techniques for Horn-SHIQ. This step may result in an exponential blow-up in the size of the rule set but preserves semantic equivalence.
Translation to DL Automata:
The normalized Horn-ALC $\not\exists$ query is then mapped to a DL automaton, a novel finite-state device.
- Structure: The automaton consists of states corresponding to concept names and a special accepting state ( $q_{acc}$ ). Transitions are either binary (labelled by classes or role expressions, moving from one state to another) or multi-ary (labelled by $\varepsilon$ , splitting a state into a set of states).
- Semantics: An accepting run is defined as a finite rooted tree where nodes are labelled with state-constant pairs. The tree structure mirrors the derivation of facts via the "chase" procedure. The automaton accepts a fact set if there exists a run starting from the initial state and constant that ends with all leaves labelled by the accepting state.
Stratification and Rewriting to PQs:
The core contribution lies in identifying a sufficient condition for rewriting: stratification.
- Stratification: The authors define a dependency relation ( $\succ_A$ ) between states based on the automaton's transition function. A dependency exists if a path involves a binary transition (role) followed eventually by a multi-ary transition. An automaton is stratified if this dependency relation is acyclic.
- Rewriting Algorithm: For stratified automata, the authors construct an equivalent Positive Two-Way Regular Path Query (PQ). This is done inductively by stratum:
  - For states in the lowest stratum (no dependencies), the query is constructed directly using regular expressions derived from the binary transitions (modeled as Non-Deterministic Finite Automata).
  - For higher strata, the construction recursively incorporates the PQs of dependent lower strata, introducing existential quantifiers to handle the branching caused by multi-ary transitions.
- This construction guarantees a finite PQ because the acyclic nature of the stratification prevents infinite recursion.
Mapping to GQL:
Finally, the resulting PQ is transformed into a Union of Conjunctive Two-Way Regular Path Queries (UC2RPQ). Since UC2RPQs are a central fragment of GQL, this establishes the final rewriting.

Key Contributions

DL Automata Formalism: The introduction of DL automata as a bridge between Horn-ALCHI semantics and path-based query languages.
Stratification Condition: The identification of stratification as a general sufficient condition for GQL-rewritability. This condition rules out specific cyclic dependencies known to increase complexity but allows for a broader class of queries than previous approaches.
General Rewriting Procedure: A complete, constructive algorithm that transforms a class of Horn-ALCHI queries into GQL formulas via the intermediate steps of normalization, automata construction, and stratified PQ generation.
Subsumption of Prior Work: The authors demonstrate that their class strictly subsumes:
- DL-Lite: Queries in DL-Lite trivially yield stratified automata (with a single stratum).
- Harmless Linear ELHI: The proposed class covers queries that fall outside the "harmless" restrictions of prior ELHI rewriting work.
- ELH $^{ql}_i$ : The class includes queries (like the example in the paper involving Crit and Acc) that are not local in the sense of ELH $^{ql}_i$ but are still stratified and thus rewritable.

Results and Significance
The paper establishes that a significant and practically relevant subclass of Horn-ALCHI OMQs can be rewritten into GQL.

Expressiveness: The approach handles queries that were previously considered non-rewritable into GQL fragments, such as those involving complex interactions between inverse roles and conjunctions in rule bodies (e.g., $Sens(x) \land Onl(x) \to Crit(x)$ combined with $Crit(x) \land Acc(x, y) \to Trust(y)$ ).
Completeness: The authors acknowledge that the condition is sufficient but not necessary. There exist Horn-ALCHI queries that are GQL-rewritable (e.g., those requiring nested regular path queries) but do not satisfy the stratification condition.
Practicality: The authors note that while the normalization step can cause an exponential blow-up, the resulting stratification check is decidable. They suggest that empirical evaluation on real-world repositories (like the Manchester OWL Repository) is a necessary next step to determine how many practical queries fall into this class.

Conclusion
The paper provides a theoretical foundation for leveraging GQL to evaluate ontology-mediated queries over expressive DLs. By introducing DL automata and the concept of stratification, the authors offer a robust method to determine rewritability, extending the applicability of GQL beyond simple DL-Lite scenarios to more complex, expressive knowledge bases. The work positions GQL as a viable target language for a broader spectrum of OMQs, bridging the gap between expressive ontological reasoning and modern graph query processing.

Technical Summary: A General Sufficient Condition for Rewriting Horn-ALCHI Atomic Queries into GQL

More like this