Executable Normative Update Semantics

42 concepts27 papers1 proposal

To build autonomous systems that operate safely in human environments, we must teach them rules. However, standard programming languages lack native support for normative concepts like obligations, permissions, and prohibitions (Aqueo Kamada et al.). Early attempts to formalize these concepts relied on classical logic or static deontic logic frameworks, which evaluate whether a global world state is compliant or violated (Robert Kowalski et al.; Tomasz Jarmużek et al.).

But real-world norms are rarely static. As Leendert W. N. van der Torre et al. point out, traditional deontic logics are primarily descriptive: they can tell you if a current state breaks a rule, but they struggle to model the dynamic process of creating, modifying, or revoking rules—such as when two agents sign a contract or issue a command. To bridge this gap, a research direction has emerged around executable normative update semantics, which treats norms not as rigid global constraints, but as dynamic, state-changing operations that can be compiled and executed in real time.

From States to Actions

The first step toward making deontic logic dynamic is shifting the focus from states to actions. In a foundational paper, L. Thorne McCarty argued that defining permissions and obligations over static world states inevitably leads to logical paradoxes. Instead, McCarty proposed defining norms over state-transition actions.

By embedding deontic operators recursively back into the primary state-description language, a system can track how obligations change over time based on prior actions. For example, instead of evaluating whether the state "the user has paid" is globally required, the system evaluates the action "the user must pay within 30 days of ordering." This recursive structure allows nested normative statements to update dynamically as an agent executes specific behaviors.

Modeling Norms as State Transitions

If actions change obligations, then the act of establishing a new rule must itself be modeled as a state transition. This is the core intuition behind Multi-Agent Deontic Update Semantics (MA-DUS), introduced by Leendert W. N. van der Torre et al..

Instead of treating a new contract or law as a statement with a fixed truth value, MA-DUS treats it as an operation that updates an agent's internal information state. The authors formally separate the act of establishing a rule from the subsequent evaluation of compliance. This allows autonomous agents to dynamically update their commitments as they interact, processing new obligations as changes to their internal state rather than rewriting a static knowledge base.

Managing Exceptions and Contextual Flips

Real-world rules are non-monotonic: they are full of exceptions, and a rule that holds true in one context can be completely canceled or reversed by a small change in the environment. For instance, Caleb Ziems et al. demonstrate that situational social norms require complex conditional logic (such as Disjunctive Normal Form) because an action's permissibility can flip entirely based on specific roles and attributes.

To handle this computationally, researchers integrate modal operators into non-monotonic frameworks. Leendert W. N. van der Torre et al. utilized dyadic modal logic to map conditional obligations to specific contexts, allowing rules to be "overshadowed" without being completely erased. Similarly, Nikos Dimaresis et al. combined modal operators with defeasible logic, allowing systems to resolve conflicting policies by assigning priorities to rules. This ensures that when an exception occurs, the system can gracefully pivot to a new normative state.

Executable Compilation and Real-Time Enforcement

For these dynamic logics to be useful, they cannot remain purely theoretical; they must be compiled into executable code. Andrés García-Camino et al. developed a method for compiling high-level normative logic into low-level, rule-based executable formats, effectively creating a "machine language" for norms that can coordinate multi-agent systems in real time.

This execution capability enables proactive and supervisory architectures:

  • Proactive Interventions: Jean Oh et al. developed a prognostic normative reasoning framework that evaluates predicted future state trajectories against a library of deontic rules. If a violation is predicted, the system autonomously searches for the nearest compliant state to intervene before the violation occurs.
  • Real-Time Supervision: Ezio Bartocci et al. integrated a defeasible deontic theorem prover as a real-time supervisor for reinforcement learning agents, filtering out impermissible actions on the fly based on a dynamic set of norms.
  • Runtime Rule Mutation: When rules themselves change at runtime, systems cannot afford to recompute all permissions from scratch. Raphael Volz et al. introduced techniques to treat rules as mutable data, allowing for the incremental maintenance of dynamic logic programs by mathematically tracking which facts are orphaned or generated when a norm is added or removed.

By treating norms as dynamic, action-oriented, and executable updates, this paradigm moves AI beyond rigid, brittle rule-following and toward fluid, context-aware normative reasoning.

Key Foundational Work

Permissions and Obligations (1983) — contributed 4 concept elements to this direction.
Permissions and Obligations (1983) — contributed 4 concept elements to this direction.
Everything You Always Wanted to Know About Authority Structures But Were Unable to Represent (1980) — contributed 1 concept elements to this direction.
History & citationVersion 1 · 2026-10-04

Current · Permanent link

View frozen version 1

Cite this direction

Latest version (a living page):

@misc{lacuna_recursive_deontic_embedding_28babe39,
  title = {recursive deontic embedding},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/recursive-deontic-embedding/rdr_28babe39e8bf4515ba84e61885972561},
  note = {Latest version of a living research direction; cite a version for a fixed text. Accessed 2026-11-21},
}

This exact version (version 1, frozen text):

@misc{lacuna_recursive_deontic_embedding_28babe39_v1,
  title = {recursive deontic embedding},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/recursive-deontic-embedding/rdr_28babe39e8bf4515ba84e61885972561/v/1},
  note = {Version 1, frozen 2026-10-04. Accessed 2026-11-21},
}
About

These directions overlap with this one through shared papers.

See something wrong? Report a mistake