Deontic Event Calculus

Formally tracks the state of a normative position through time, from activation by a triggering event to fulfillment, violation, or expiration. Unlike static deontic logic, it models the dynamics of duties as the world changes.

• Activation: An obligation becomes effective upon a specific event (e.g., contract signing).
• Fulfillment: The obligated action is performed within the deadline.
• Violation: A deadline passes without fulfillment, triggering contrary-to-duty rules.
• Expiration: The obligation ceases to exist due to a terminating condition.

Uses fluents to represent time-varying normative properties (e.g., obligated(partyA, deliverGoods)) and events that initiate or terminate them. The calculus provides axioms that govern how fluents persist or change.

• Initiates: An event starts a fluent (e.g., sign(contract) initiates obligated).
• Terminates: An event ends a fluent (e.g., deliver(goods) terminates obligated).
• HoldsAt: A predicate to query whether a fluent is true at a specific time point.
• Clipping: The mechanism for resolving what happens when events overlap or conflict.

Natively handles Chisholm's Paradox and other contrary-to-duty (CTD) scenarios by modeling time explicitly. When a primary obligation is violated at time t1, a secondary obligation is activated at t2.

• Avoids the logical contradictions that plague Standard Deontic Logic.
• Models compensatory obligations as events triggered by violation events.
• Enables deadline monitoring with automatic escalation of remedial duties.
• Supports normative hierarchies where higher-priority obligations override lower ones.

Serves as the formal backbone for runtime compliance verification in automated systems. A stream of real-world events is checked against a model of active obligations to detect violations in real time.

• Event Trace: A log of timestamped actions from an enterprise system or smart contract.
• Normative Model: A set of deontic rules encoded in the event calculus.
• Violation Detection: The engine flags any HoldsAt(violated, t) state.
• Audit Trail: Generates a provable record of all normative state transitions for regulatory reporting.

Combines with semantic graph representations of legal entities to ground temporal obligations in real-world relationships. The event calculus provides the temporal reasoning layer over a static knowledge graph.

• Nodes: Represent parties, contracts, and clauses.
• Edges: Represent deontic relations (e.g., hasObligation, hasPermission).
• Temporal Layer: The event calculus fluents are mapped to graph relations, making them time-aware.
• Query: Enables complex queries like 'Find all obligations active on January 15th that were violated within 30 days.'

Extends the core calculus with sanction rules that are automatically triggered by violation events. This closes the normative loop from detection to consequence.

• Sanction Event: An event type that initiates a penalty fluent (e.g., imposeFine).
• Grace Periods: Modeled as temporal windows between violation and sanction activation.
• Cumulative Penalties: Escalating sanctions for repeated violations are tracked as incrementing fluents.
• Remediation: Fulfillment of a sanction obligation terminates the penalty state.

The formal branch of logic dealing with obligation, permission, and prohibition. It provides the axiomatic foundation for all normative reasoning systems by introducing operators like O (it is obligatory that) and P (it is permitted that).

• Distinguishes between what is the case and what ought to be the case
• Forms the semantic bedrock upon which temporal deontic calculi are built
• Essential for understanding the truth conditions of normative statements

A conditional obligation that activates precisely when a primary duty has been violated. CTD structures represent the normative fallback rules that govern non-ideal compliance scenarios.

• Example: "You ought not to cause damage; but if you do, you ought to repair it"
• Deontic Event Calculus explicitly models CTD activation as a state transition triggered by a violation event
• Resolving CTD paradoxes is a core motivation for temporal deontic formalisms over static SDL

An extension of deontic logic that incorporates action modalities and state transitions, enabling formal modeling of how obligations change as agents perform actions over time.

• Uses dynamic logic operators like [α]O(φ) — "after action α, it is obligatory that φ"
• Bridges the gap between static normative statements and event-driven obligation lifecycles
• Deontic Event Calculus inherits this action-oriented semantics while adding explicit temporal fluents

The algorithmic detection and reconciliation of contradictory legal rules that prescribe incompatible actions. Resolution strategies follow established jurisprudential principles.

• Lex superior: Higher authority prevails
• Lex specialis: More specific rule overrides general rule
• Lex posterior: Later enactment supersedes earlier one
• Deontic Event Calculus must incorporate these meta-rules to resolve conflicts in obligation fluents at runtime

An algorithmic engine that evaluates a trace of agent actions against a formalized set of deontic rules to detect violations and measure adherence. It operates as the runtime verification layer for normative systems.

• Consumes event logs and outputs violation reports with timestamps
• Deontic Event Calculus provides the temporal reasoning backbone for determining when an obligation was active and whether it was fulfilled before expiration
• Essential for regulatory technology (RegTech) and smart contract auditing

A formalization of normative reasoning as a set of variables and deontic constraints, solved by finding assignments that satisfy all applicable obligations and prohibitions without conflict.

• Variables represent actions, states, or agent choices
• Constraints encode obligations (must include), prohibitions (must exclude), and permissions (may include)
• Deontic Event Calculus can be compiled into a CSP for planning compliant action sequences over time