Deontic Logic Reified: a deontic logic for the Semantic Web

Tracking #: 4097-5311

Authors: 
Livio Robaldo

Responsible editor: 
Pascal Hitzler

Submission type: 
Full Paper
Abstract: 
This paper introduces Deontic Logic Reified, a novel deontic logic implemented in RDF and SPARQL for automated compliance checking over Semantic Web data. The framework is designed to support scalable deontic reasoning by leveraging RDF as a standard knowledge representation layer, thereby enabling seamless interoperability with existing data ecosystems within the Semantic Web. Deontic Logic Reified incorporates and extends research that I have conducted over the last five years, primarily presented in three key publications of which I am the main author: [1], [2], and [3]. This paper integrates the results of these contributions while addressing their complementary limitations. In particular, the paper extends the RDF/SPARQL framework in [3], which provides the core building blocks reused here, with constructs investigated and compared in [2], which surveys the main legal reasoners in the contemporary literature on compliance checking, as well as with constructs for implementing a temporal dimension for legal norms, which has been studied in the literature primarily from a theoretical perspective despite its crucial role in compliance checking. These extensions enable the resulting framework to achieve large-scale legislative coverage in a unified and executable manner. To demonstrate its applicability, a substantial subset of norms from the European General Data Protection Regulation (GDPR), previously formalised in [1], is translated into the proposed formalism and executed over RDF data. The results show improved computational performance compared to the SHACL-based reasoner surveyed in [2], which is the only one among those considered that is capable of natively processing RDF data. All examples presented in this paper are available in https://github.com/liviorobaldo/dlr-swj, together with Java procedures to execute them.
Full PDF Version: 
Tags: 
Reviewed

Decision/Status: 
Major Revision

Solicited Reviews:
Click to Expand/Collapse
Review #1
By Víctor Rodríguez-Doncel submitted on 01/Aug/2026
Suggestion:
Minor Revision
Review Comment:

This is a nice and much necessary paper, reading it in depth requires a considerable effort though. Some claims on the novelty seem too strong to me, as I will argue but the integration of defeasible deontic logic with temporal logic and native RDF/SPARQL executability over Semantic Web data makes the paper a very valuable contribution: the author integrates three prior works (RDF/SPARQL deontic framework, defeasibility, temporal dimension) into a single executable deontic logic. The system is demonstrated on a subset of GDPR and it is compared against a SHACL-based reasoner.

ORIGINALITY

- The integration itself: reified deontic modalities + defeasibility via superiority relations + achievement/maintenance temporal semantics, all natively executable in SPARQL, is a genuine and useful synthesis.

- However, the paper's central negation trick ("using RDF reification to represent that a triple is true or false," attributed to [3] as a main insight) is not new: essentially the same idea, using reification/quoting to represent a triple's negation under RDF's Open World Assumption, appears as early as a 2001 W3C 'www-rdf-logic' mailing-list message by our beloved Aaron Swartz [R1]. Other contributions in academmic settings have used that idea, too.

- Probably the author ignored the very much recent work of SHACL 1.2 Rules [R4]. It is only a W3C Working Draft of Dez. 2025, but it provides native stratification/fixpoint semantics. This would be the standards track to address the `sh:order` non-determinism problem the paper cites as a SHACL limitation. Of course, this doesn't replace the paper's defeasibility mechanism (which resolves substantive normative conflict, not just execution order) and current implementations still lack full RDF reification support, but it deserves a mention. I wonder what else would the author change after considering Steyskal's work.

- The dismissal of related RDF-based compliance frameworks (refs [15]-[19]) as merely "evaluated primarily on constructed examples or restricted use cases" is inaccurate for at least Piero Bonatti et al. [17], which came out of the EU H2020 SPECIAL project with real-time, operationally-scoped evaluation [R2]. Even the author mentions that in the prior systematic comparison [2]. I would simply claim to "no prior work demonstrates covrage for a full-regulation"

- I think the work of Pandit, GDPRtEXT [R3] would have been useful in the "semantic web" part of the work (not for the "logic" one). GDPRtEXT i an RDF/SKOS resource anchoring GDPR articles to unique identifiers via ELI - directly relevant prior art for how the D-KB links rules to GDPR text.

- Also missing: Natalya Keberle's prior work on temporal extensions to OWL/RDF [R5] (OWL-MeT, combining metric temporal logic with description logic to represent temporal classes), is old but iti s directly relevant to Section 4's treatment of the temporal dimension of norms and worth situating this contribution.

SIGNIFICANCE OF THE RESULT

- The abstract's claim of "large-scale legislative coverage" is again too much to say: if i understand it correctly (maybe I am wrong) only Chapter II of the GDPR (65 of 966 D-KB rules) was translated and tested. Also representativeness is argued via the author's own prior taxonomy [2]. Using some else's work, or proving at massive scale in another manner (traffic rules work of Saarbrucken's team?) would have been great.

- The D-KB -> Deontic Logic Reified translation was performed manually by a single author with no independent verification. The so called DAPRECE methodology was therefore not really followed, unlike the D-KB itself, which passed by expert validation (see [44]).

- Same idea: The performance comparison (Table 1) has a single competitor, the author's own earlier SHACL reasoner [18]...

- The generate-and-test verification methodology (Sec. 6) is untested at scale: the author himself notes it became "increasingly difficult to keep track of overall consistency" already at 65 rules. The independence argument used to avoid combinatorial explosion (treating brother branches as separable) holds only if the rule-interaction structure is a clean tree; cross-article dependencies in real legislation may break this. No complexity analysis is offered.

- Worth mentioning: the author keeps the entire framework within normative SPARQL/SHACL Core constructs, avoiding non-normative extensions such as SHACL-JS ([R8]) - a 2017 W3C Working Group Note that never advanced to Recommendation status and would have tied the implementation to a specific JavaScript engine. I am myself a Java developer who has used Apache Jena for over 20 years and can attest that this restraint comes at a real cost in readability - the nested `FILTER(IF(...))` constructs in rules like (36)-(37) are reallly harder to parse than an equivalent JavaScript "helper function" would be - but it pays off in portability and in keeping every inference step auditable as declarative RDF/SPARQL rather than procedural code, which is squarely in line with the paper's own stated motivation against opaque, non-symbolic reasoning. Well, no syntactic sugar....

QUALITY OF WRITING
- Readable, indeed at a great intellectual effort. I would not deter the reading from continuing: the very ferst formula (1), the core pattern is introduced before any concrete example. Maybe placing the example (as later given in (2)) before the abstract formula would have been nicer to the reader... In order to read this paper, reading at least the three previous references of the author is necessary. Indeed, this is not a complain, only a warning to the reader...

- "ET(eo) ∧ ET(e)" in rule (5) relies on "ET" being instantiated to the same type predicate on both sides. Maybe this schema-variable convention that should be made explicit.
- Formula (44) implicitly requires the nomination event and the processing event to share the same interval "t1", an assumption not flagged in the text.

- Note 4 cites a dead URL ("isi.edu/~hobbs/disinf-tc.html"); probably you want to point readers to Ch. 4 ("Logic Reified") of Gordon & Hobbs [R6] instead. I say probably because I could not find Hobbs' book chapter myself. Only the summary of the reified logic that he seems to have posted in a web... I hope it was not a necessary reading.

- I like the paper's opening appeal to MacCormick on the need for an explicit justificatory chain in legal reasoning. It is a mandatory reading in many university courses, alongside with Alexy's more formally structured apparatus of rules and principles [R7], perhaps you want to check it too

4. ASSESSMENT OF THE PROVIDED RESOURCES

That is to say, the repo: (github.com/liviorobaldo/dlr-swj)

VERY IMPORTANT NOTE / DISCLAIMER
The value of my review is limited because I have not executed the code in the repo myself. I do not plan to do so until after the summer break; my comments on the resources are solely based on a fast inspection of the repository's structure and README only. Maybe I will add some informal "comments" after I play with the software... In any case, a couple of observations:

A. Organization / README. The repository has a README describing its two main folders and the purpose of each .bat script. It is clear enough to orient a reader, but is minimal: no LICENSE file, no explicit dependency/version pinning (Java version, Apache Jena version,, only the TopBraid SHACL API version appears, and only in the paper's footnotes, not the README), and no build system (Maven/Gradle) beyond a rustic compileAll.bat.
Well, if it works it does not mind.

B. Completeness for replication. I did not replicate.
C. Repositoy choice. Good, but please make resources persistent using Zenodo. There is no LICENSE file.
D. Overall completeness. I understand the following is at least covered:a gdpr Chapter II subset, 12 examples, generate-and-test and performance experiment).

CLOSING REMMARK
The paper's core building blocks, the deontic modalities of permission/obligations/prohibitions are precisely the modalities that the W3C's Open Digital Rights Language (ODRL) has been standardizing for policy expression since becoming a Recommendation in 2018. The W3C Workshop on the Future of ODRL (which took place very recently in London https://www.w3.org/2026/ODRLWS/) has presentations spanning data spaces, AI governance, and regulatory compliance. pratical applications for the theoretical work prsented in this paper. I would encourage the author to engage with the ODRL Community Group going forward. Bonatti (mentioned in my text above) is also actively participating, and our ODRL Formal Semantics document is worth a comment: https://w3c.github.io/odrl/formal-semantics/

SUMMARY OF RECOMMENDED ACTIONS
Summary of actions I would do:

- Make more humble the novelty and coverage claims: narrow "these approaches have been evaluated primarily on constructed examples" to something like "no prior work demonstrates full-regulation-scale coverage," and soften "large-scale legislative coverage" in the abstract to reflect that only Chapter II of the GDPR was actually translated and tested.

- Add the missing citations: GDPRtEXT, the Aaron Swartz precedent for the reification-based negation trick, SHACL 1.2 Rules, and Keberle's temporal OWL/RDF work, none require new experiments, just textual additions.

- Clean the repository: add a LICENSE, a GitHub description/topics, and a tagged release (ideally archived with a Zenodo DOI) for the exact version used in the paper.

- Make a demo to play with the axioms, and to do the transformations form the i/o logic.

- Mention in the scope the importance it might have on ODRL3.

## References cited in this review

[R1] A. Swartz, message to the W3C `www-rdf-logic` mailing list, 3 April 2001. https://lists.w3.org/Archives/Public/www-rdf-logic/2001Apr/0058.html

[R2] P.A. Bonatti, L. Ioffredo, I.M. Petrova, L. Sauro, I.R. Siahaan, "Real-time reasoning in OWL2 for GDPR compliance," Artificial Intelligence 289 (2020), 103389.

[R3] H.J. Pandit, K. Fatema, D. O'Sullivan, D. Lewis, "GDPRtEXT – GDPR as a Linked Data Resource," in Proc. 15th European Semantic Web Conference (ESWC), Heraklion, Crete, 2018.

[R4] W3C Data Shapes Working Group (S. Steyskal et al., eds.), "SHACL 1.2 Rules," W3C Working Draft, 9 December 2025. https://www.w3.org/TR/shacl12-rules/

[R5] N. Keberle, "Temporal classes and OWL," in Proc. 6th OWLED Workshop on OWL: Experiences and Directions, 2009.

[R6] A.S. Gordon, J.R. Hobbs, *A Formal Theory of Common Sense Psychology: How People Think People Think*, Cambridge University Press, 2017.

[R7] R. Alexy, *A Theory of Legal Argumentation: The Theory of Rational Discourse as Theory of Legal Justification*, Clarendon Press, Oxford, 1989.

[R8] H. Knublauch, P. Maria, "SHACL JavaScript Extensions," W3C Working Group Note, 8 June 2017. https://www.w3.org/TR/shacl-js/

Review #2
Anonymous submitted on 04/Sep/2026
Suggestion:
Reject
Review Comment:

Originality: The paper does not introduce any novel ideas. It is more like a selection of different approaches followed by an encoding in RDF, which itself uses known techniques.

Quality of writing: The paper is clear, however the presentation is uniquely based on specific examples, while more general descriptions would be needed.

Significance of the results:

This paper is a large exercise in encoding norms in RDF and SPARQL. While the effort put in the work is remarkable, the proposed approach is not supported by a solid scientific methodology, in particular the approach is lacking a satisfactory validation.
The paper proposes norm and situation encodings whose correctness and scalability is not demonstrated. In many cases the encoding is ad-hoc and sometimes the author himself declares that the simplified encoding adopted does not scale to the general case.
Consequently, several things may go wrong, for example:

- If the SPARQL rules that encode the semantics of deontic modalities are interpreted verbatim, then the thematic roles of obligations/permissions on one side, and really-existing action on the other side, must have exactly the same values. However, in RDF, structured objects (e.g. dates) are usually encoded by reifying the object with a blank node, and the same object (i.e. the same date) may be reified by different blanks. Clearly, in this case, if the thematic roles of the reified deontic statement and the existing action were required to have the same value, then some compliance/violations would not be detected. One should rather match the (sub)graphs that represent the two values, but this is a subgraph isomorphism problem which is NP-complete. Thus the choice is between not recognizing compliance and violations - on one side - and making compliance/violation checking intractable. This aspect goes unnoticed in the paper because there is no systematic approach to the definition of the policy language and the definition and the encoding of its semantics; by introducing these notion merely by examples, the difficulties that may arise remain under the carpet.

- The rules with existentials in the head are implemented by creating new blank nodes and checking that similar objects do not (yet) exist, to avoid infinite applications of the rule. However, in general, blocking the generation of new similar blanks in this way is not correct (this is why "chases" have been introduced in the theory of databases). The correct way of blocking an infinite generation of similar objects (when this is possible without missing valid inferences) is way more complex. The author is satisfied with simple examples, where the naive blocking technique intuitively works well; in this way, however, there is no guarantee that the approach works well in different contexts, with different combinations of norms and rules.

- The rich version of SPARQL used in norm and rule encoding is at least as expressive as conjunctive queries with negation, whose complexity in general may reach EXP (exponential time). The author does not discuss under which conditions the RDF+SPARQL encoding avoids this complexity.

- Are the SPARQL rules to reason about temporal relations complete? (e.g. with respect to Allen's temporal algebra) That is, can some inclusion or intersection relations be missed by the proposed implementation, causing a wrong assessment of compliance and violations?

- Is the ad hoc modelling of disjunction through DeleteOrRectify treated exhaustively? For instance, what happens *in general* when two rules activated by a Delete fact and a Rectify fact, respectively, produce the same consequence? Does the implementation find this consequence or the knowledge engineer must figure out that a valid consequence is missing and add manually more ad-hoc rules to fill in the gap?

- How many ad-hoc workarounds such as DeleteOrRectify and the formalization of "without delay" are in the knowledge base? To what extent can they be generalized to address the needs of other normative systems?

- Is the translation of the 999 rules from reified I/O logic to RDF+SPARQL correct? If there were an automated translation system, one might prove its correctness by leveraging the declarative semantics of reified i/o logic and SPARQL. Unfortunately, this is impossible since the translation has been done manually. The empirical evaluation performed by the author does not guarantee the by adding further rules undesirable results may occur due to the interference of old and new rules.

- Last but not least: Are the above aspects the only "gray areas" of the proposed approach? Would deeper investigations reveal more disputable points?

Given the above discussion, the potential advantages of symbolic systems are lost. There are no formal guarantees of correctness or completeness, and the approach cannot be regarded as "reliable". Moreover, it is well-known that tracing and validating the behavior of a large production system like this is a painful and error-prone process.

Moreover, I am not convinced that in the absence of cycles among exceptions the SPARQL rules always give the correct result (I am referring to the discussion on p. 14-16). Please explain why there exist no alternative rule evaluation orders such that an action is made Active before its blockers are derived.

In order to address the above points one should radically change approach. The standard way of addressing the above points goes through: an exhaustive, formal definition of the grammars of representation languages involved (I/O logic, deontic logic, RDF/SPARQL, possibly restrictions thereof, sufficient for encoding a class of norms of interest - grammar restrictions should be formally specified, though), and their formal semantics. Semantics should possibly be model-theoretic, so as to have an independent notion of inference against which axiomatizations and implementations can be proved correct and complete. A formal definition of logical consequence can be used to estimate the computational complexity of compliance and violation checking, so as to predict or exclude scalability issues. Using the formal semantics, the translations between different logics should be formally proved correct and complete. Such results should not be taylored to a single, specific example, but should hold for all the norms expressible with the considered representation languages.

Review #3
Anonymous submitted on 09/Oct/2026
Suggestion:
Accept
Review Comment:

Semantic Web Journal Review
Accept with grade 90
Summary paper: This paper introduces Deontic Logic Reified, a new deontic logic framework for compliance checking that enables direct reasoning over the Semantic Web. The work builds on earlier research by the author, providing both a coherent synthesis of previous contributions and several extensions, including a temporal dimension and strategies for handling defeasibility.
The paper illustrates the proposed framework by translating parts of the GDPR into the formal language. Furthermore, it develops a generate-and-test methodology for formally validating the translated formulae and demonstrates how the resulting representations can be executed automatically. Finally, the paper compares the proposed approach with an existing SHACL reasoner and shows that the implementation developed in this work achieves better computational efficiency.
Overall assessment: This is a very impressive, well-motivated, and highly relevant paper. It presents Deontic Logic Reified as a framework for compliance checking that enables direct reasoning over the Semantic Web. The paper builds coherently on the author's previous work while extending it with a temporal dimension and mechanisms for handling defeasibility. The GDPR case study provides a particularly valuable demonstration of the practical relevance of the framework.
A major strength of the paper is that it moves beyond theoretical development towards a concrete and important application. The generate-and-test methodology for validating the formalizations, together with the automatic execution of the encoded representations, is particularly valuable. The comparison with an existing SHACL reasoner further strengthens the contribution by demonstrating improved computational efficiency.
Overall, the results are significant and represent a natural and convincing extension of the author's earlier research. I can see potential for this line of work to contribute to the development of automated compliance-checking systems and, eventually, to support legal practitioners and domain experts.
I therefore recommend acceptance. I have a number of minor comments and further questions that I believe could improve the clarity of the paper in certain aspects. Nevertheless, these comments do not negate the quality of the work.
First, I will shortly comment on the originality and significance of the work, while posing more elaborate questions later on in the review.
Originality
The paper builds on the author's previous work, but extends it in meaningful ways through the integration of temporal reasoning, defeasibility, and a methodology for validating and executing formalised legal norms. The literature review includes a solid summary of different approaches in defeasibility and compliance checking, comparing negation-as-failure to priority orderings specifically for the defeasible reasoning part of this paper. However, such a section is missing in the temporal component, even though there has been extensive research on temporal logic.
- Could the paper add a section on this comparison or explain shortly why this is missing?
Significance of the results
The results are significant, in particular, the integration of temporal reasoning and defeasibility, together with the validation and execution of formalized legal norms, represents a valuable contribution that is both significant to this specific journal as the field of AI&Law more broadly. While the current purpose is to provide a formal language and rules for the formal representation of the GDPR, the paper convinces that there is a realistic future in finding practical applications in legal compliance and supporting the work of legal practitioners.
- While this work has been focusing on the GDPR, is it likely that part of these encodings with similar rule structures can be used to encode compliance checking for other legislation, for example, traffic law?
Quality of writing.
The paper is exceptionally well-written, and each step is well-justified, making it easy to follow this paper.
There are some minor points in clarity that could be addressed:
- The encodings in RDF and SPARQL, are sometimes hard to decipher and could benefit from a clearer representation. For example, 15b. could become:
b :egba :Rexist, :Give;
:has-agent :Bill;
:has-object :500pounds;
:has-recipient :Jack.
:Bill a :Man.
:500pounds :value-of :r.
:r :rent-of :Bill.
:Jack :landlord-of :Bill.

- The deontic traditional scheme has been mentioned a few times throughout this paper. However, this terminology is not familiar or used in the field of deontic logic. Where did the author get this from and what does he mean? Do the authors mean “Standard Deontic Logic”?
- Towards the end of the paper, ABoxes are referred to more often, but their syntax and exact role could be explained better.
- Page 9, formula12b: Is elj a typo? Should it not be elp?
- Page 21, lines 50-51: this sentence is grammatically odd.
- Page 24, formula (43) is especially hard to read and would benefit from a more line by line explanation of what is meant here.
- Page 28, lines 41-50: the authors writes 4a, 4b, where they seem to refer to 54a and 54b
- Page 39, lines 12-18: It is not so clear how the sequence of numbers exactly is supposed to be read here. Could this be clarified further?
- Page 40, the paper mentions 50% probability. What is this the probability of?

Further questions & Minor points:
The following points are divided into two categories, one more focused on deontic logic and one on conceptual points and questions for this paper.
Deontic logic
- The paper addresses what to do in exceptions of laws and defeasibility very elaborately and convincingly. However, another example of a similar kind of concept are contrary-to-duty obligations. Where violating an obligation results in another obligation. These also appear in law but should be treated differently from defeasibility. Would your language be able to handle these?
- Permissions are introduced here as normative concepts related to obligation, but are actually very complex and there are many types of permissions, weak vs strong, bilateral vs unilateral. Is there only one type occurring in the GDPR? Are you aware of these types and are they part of future work or will they not be encoded?
- A similar concern applies to prohibitions. In this paper, prohibitions are undefined, but takes as a type of obligation, even though legally they may have a different role. Do you have any plans to address this in the future?
- Some obligations may hold indefinitely or without an explicitly bounded temporal interval. Does the framework support obligations whose temporal scope extends from negative infinity to positive infinity? If so, how are such obligations represented? If not, what limitations arise from the temporal representation adopted in the paper? Would allowing unbounded intervals introduce computational difficulties?
- The paper appears to favor priority rules over negation-as-failure as a mechanism for handling exceptions. Could the authors explain the rationale for this choice? What are the respective advantages and disadvantages of these approaches in the context of legal compliance checking, and why are priority rules considered more appropriate for the proposed framework?
- The paper clearly explains how norms are encoded and how a situation can be represented to determine whether it complies with a given norm. However, it is less clear what the output of the compliance-checking process looks like in practice. When a norm is fulfilled or violated, what exactly does the system return? Does it produce a binary classification, a formal representation of the result, an explanation of the reasoning, or some combination of these? It would be helpful to clarify how the results are presented and how they might be interpreted by users, particularly legal practitioners.
- What exactly is the conceptual difference between a non-obligation and a permission? Generally, in deontic logic, these the negation of an obligation implies the permission for that negated action. It seems like the non-obligation is supposed to mark something like “indifference”. Why is it important to formalize this concept separately from permission in the specific framework presented here?

Conceptual:
- Could the authors elaborate on the motivation for automated compliance checking and explain what advantages the proposed approach offers over less formal or manual approaches? More broadly, what role do the authors envision for human users and legal experts in a complete system for representing legal rules and checking compliance? In particular, which aspects of the process could be automated, and which would still require human judgment and interpretation?
- Has there been any involvement of legal experts in this series of research, for example, in the selection, interpretation, or formalisation of legal norms? If so, it would be interesting to learn more about their role. If not, how do the authors envision incorporating legal expertise into future developments of the framework?

Finally, regarding the code in the provided git repositories: these are well-organized and it is clear how to run these and which file contains which part of the experiments. As github is used as a repository, it is appropriate for long-term discoverability.