💬 NLP

Axis-Aligned Semantics for ODRL: Resolving Dimensional Ambiguity in Policy Constraints

This paper resolves the dimensional ambiguity in ODRL spatial constraints by introducing an axis decomposition method that transforms multi-axis operands into axis-specific scalar intervals, enabling sound and complete conflict detection through box comparison and validated via a new profile and extensive formal verification.

Original authors: Daham Mustafa, Diego Collarana, Sabrina Kirrane, Christoph Lange, Christoph Quix, Rafiqul Haque, Yixin Peng, Stefan Decker

Published 2026-05-26

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Daham Mustafa, Diego Collarana, Sabrina Kirrane, Christoph Lange, Christoph Quix, Rafiqul Haque, Yixin Peng, Stefan Decker

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 organize a massive digital library where people share 3D scans of historical artifacts, high-resolution photos, and maps. To keep things safe and fair, the library uses a set of rules called ODRL (Open Digital Rights Language). These rules act like bouncers at a club, deciding who can enter and what they can do.

However, the paper identifies a confusing problem with how these rules currently work when dealing with 3D objects (things with width, height, and depth).

The Problem: The "Blind" Bouncer

Currently, ODRL rules look like simple math sentences:

Rule: "Size must be less than 1920."
Rule: "Size must be less than 1080."
Rule: "Size must be less than 50."

The problem is that the word "Size" is ambiguous. Is the 1920 limit for the width? The height? Or the depth?

Imagine a bouncer at a club who is told: "Only let in people shorter than 6 feet." But the bouncer doesn't know if that rule applies to height, or if it's a rule about how wide a person's shoulders are. If two people try to enter, and one is 5'11" tall but has 7-foot shoulders, the bouncer gets confused. They can't tell if the rules conflict or if they are compatible. In the digital world, this confusion means the computer system can't reliably detect if two policies are fighting each other (a "conflict") or if they work together.

The Solution: The "Axis-Aligned" Profile (OAAP)

The authors propose a new way of writing these rules called OAAP (ODRL Axis-Aligned Profile). They solve the confusion by breaking the big, vague "Size" rule into three specific, separate rules:

Width must be less than 1920.
Height must be less than 1080.
Depth must be less than 50.

Now, the bouncer has a clear checklist. They don't have to guess. They can look at the width, check the width rule, look at the height, check the height rule, and so on.

How It Works: The "Box" Metaphor

The paper uses a clever geometric metaphor to explain how this works:

Old Way: A rule was a blurry cloud. You didn't know exactly where the boundaries were in 3D space.
New Way (OAAP): Every rule is now a perfect, axis-aligned box.
- Imagine a cardboard box sitting on a table. It has a specific width, height, and depth.
- If you have a "Request" (what a user wants) and an "Offer" (what the library allows), you are essentially trying to fit one box inside another.
- If the "Request Box" is wider than the "Offer Box," they don't fit. Conflict!
- If the "Request Box" fits perfectly inside the "Offer Box," they are Compatible.
- If the "Request Box" doesn't mention depth, but the "Offer Box" does, the system says Unknown. It's like saying, "I know you fit in the width and height, but I don't know if you fit in the depth yet."

The Three-Valued Logic

Because the system is now so precise, it can give three specific answers instead of just "Yes" or "No":

Conflict: The boxes definitely do not overlap. (e.g., You asked for a width of 2000, but the rule says max 1920).
Compatible: The boxes definitely overlap. (e.g., You asked for a height of 800, and the rule allows up to 1080).
Unknown: We can't decide yet because one side didn't specify a rule for a certain dimension. (e.g., The library set a depth limit, but you didn't say what depth you need. The system waits for more info rather than guessing).

The Proof: The "Math Test"

The authors didn't just write this idea down; they built a rigorous mathematical framework to prove it works. They translated these rules into a language that powerful computer math engines (like Z3 and Vampire) can understand.

They created 256 different test scenarios (like a massive practice exam).

They fed these scenarios into four different "math brains" (computer solvers).
All four solvers agreed on every single answer.
They proved that their method is sound (it never gives a false "Compatible" answer when there is actually a conflict) and backward compatible (it works with the old rules without breaking them).

Summary

In short, the paper fixes a "blind spot" in digital rights management. By forcing rules to specify exactly which dimension (width, height, or depth) they are talking about, they turn vague, confusing constraints into clear, 3D boxes. This allows computers to instantly and accurately tell if two digital policies are fighting each other or working together, using a simple system of "Conflict," "Compatible," or "Unknown."

Technical Summary: Axis-Aligned Semantics for ODRL

Problem Statement
The Open Digital Rights Language (ODRL) is the W3C standard for expressing access and usage policies, widely adopted in data spaces such as the German "Culture Dataspace." However, ODRL represents policy constraints as triples (left operand, operator, right operand) without explicit axis identity. This creates a critical ambiguity for multi-axis digital assets (e.g., raster images with width/height, 3D scans with width/height/depth, or geospatial data with longitude/latitude/altitude).

Specifically, five spatial left operands in ODRL—absoluteSize, relativeSize, absoluteSpatialPosition, relativeSpatialPosition, and spatialCoordinates—range over multi-axis domains (products of totally ordered real-valued domains). The current syntax treats these as single, undifferentiated attributes. Consequently, policy engines cannot distinguish whether multiple constraints apply to the same axis or different ones. For instance, a policy containing (absoluteSize, lteq, 1920) and (absoluteSize, lteq, 1080) cannot be unambiguously interpreted as applying to width, height, or both. This ambiguity renders conflict detection unsound or incomplete, as engines cannot determine if constraints overlap or are disjoint. Existing formalizations of ODRL (e.g., first-order logic or rule-based semantics) typically collapse these multi-axis operands into single scalar domains, failing to resolve this dimensional ambiguity.

Methodology
The authors propose a general axis-decomposition method, instantiated as the ODRL Axis-Aligned Profile (OAAP). The methodology proceeds as follows:

Axis Decomposition: Multi-axis operands are replaced by a set of distinct, axis-specific scalar operands. For example, absoluteSize is decomposed into oaap:absoluteSizeWidth, oaap:absoluteSizeHeight, and oaap:absoluteDepth. Each new operand ranges over a specific, totally ordered domain (e.g., $(0, \infty)$ for size dimensions).
Interval Semantics: The profile restricts operators to "interval operators" (lt, lteq, gt, gteq, eq). Under this restriction, every constraint denotes a contiguous interval on its specific axis. A set of constraints on a single axis is normalized into a single interval via intersection.
Box Denotation: A policy's constraint set over a multi-axis operand is interpreted as an axis-aligned box (the Cartesian product of the normalized intervals for each axis).
Three-Valued Verdict Algebra: Conflict detection is defined using a three-valued logic:
- Conflict: The intersection of intervals (or boxes) is empty.
- Compatible: The intersection is non-empty.
- Unknown: One policy constrains an axis while the other does not (silence is not interpreted as permission).
- These verdicts are composed using Strong Kleene conjunction and disjunction, where Conflict is the bottom element and Compatible is the top.
Logical Composition: The semantics handle logical operators (and, or, xone) by aggregating box verdicts. For disjunctions, a policy is compatible if any branch pair is compatible; it is in conflict only if all branch pairs conflict.
Runtime Bridge: The framework defines a satisfaction relation where a request (a partial mapping of axis values) satisfies a policy if the values fall within the denoted intervals.

Key Contributions

OAAP Profile: An OWL 2 ontology and SHACL shapes graph that introduces 15 axis-specific left operands for the five affected spatial terms. It preserves backward compatibility by leaving non-interval operands and operators unchanged.
Formal Semantics: A denotational semantics that maps constraints to intervals and policies to axis-aligned boxes. The paper proves:
- Expressibility: Every axis-aligned box can be represented by a conjunction of well-formed axis-specific constraints.
- Soundness: A Conflict verdict guarantees that the denotations of two policies are disjoint (no request can satisfy both).
- Monotonicity: Refining a policy (narrowing its intervals) can only move the verdict toward Conflict, never toward Compatible.
- Sharpness of Unknown: If a verdict is Unknown, there exist completions of the unconstrained axes that result in either Compatible or Conflict.
Evaluation: The authors validated the framework on a benchmark of 256 policy problems derived from the BSB–BnF cultural data scenario. These problems were expressed in Turtle, compiled to First-Order Logic (TPTP) and SMT-LIB formats, and verified using four solvers: Vampire, E, Z3, and cvc5. All 256 problems were verified with full concordance across formalisms and solvers, with execution times under 11 seconds total.

Results
The evaluation confirms that the decomposition method is sound and that the interval semantics correctly resolve the dimensional ambiguity. The solvers successfully verified:

Interval and box denotations (including projection and normalization).
The conflict criterion based on endpoint precedence.
Logical composition rules for and, or, and xone.
Box containment and the properties of Unknown verdicts.
Runtime satisfaction (permit/deny decisions).
Soundness via negative examples (deliberately wrong verdicts were correctly refuted).

The results demonstrate that off-the-shelf SMT solvers (like Z3) can decide these constraints in milliseconds, supporting potential runtime conflict checking.

Significance
The paper claims that OAAP resolves the long-standing issue of dimensional ambiguity in ODRL without altering the core constraint syntax. By decomposing multi-axis operands into scalar, axis-specific terms, the profile enables sound and complete conflict detection for axis-aligned regions. The authors emphasize that this approach is not limited to spatial data; it applies to any operand over a totally ordered domain (e.g., future temporal operands). While the method is sound, the authors modestly note it is not complete for non-axis-aligned regions (e.g., aspect ratio constraints or circular shapes), which remain outside the scope of the current interval semantics. The work provides a formal foundation for governing multi-axis assets in data spaces, ensuring that policy engines can reliably determine compatibility and conflict.