Obligation Graph

The graph is composed of nodes representing legal actors (e.g., 'Employer,' 'Taxpayer,' 'Administrator') and directed edges representing mandatory actions one actor must perform for another.

• Source Node: The bearer of the duty (the obligor)
• Target Node: The beneficiary of the duty (the obligee)
• Edge Label: The specific action mandated (e.g., 'file,' 'pay,' 'disclose')

This structure directly mirrors the Hohfeldian legal relations framework, transforming jural correlatives into queryable graph patterns.

Obligation Graphs are grounded in deontic logic, a branch of modal logic that formalizes normative concepts. Each edge is annotated with a deontic modality, primarily O (obligation).

• O(A, B, φ): Actor A is obligated to Actor B to perform action φ
• Edges can carry activation conditions (predicates that must be true for the duty to arise)
• Supports contrary-to-duty reasoning for modeling violations and remedial obligations

This formal semantics enables deterministic traversal and automated conflict detection against Permission Graphs and Prohibition Graphs.

Not all obligations are absolute. Edges in the graph are often gated by conditional predicates extracted from statutory text.

• IF-THEN rules: 'IF an employer has 50+ employees, THEN the employer MUST file Form EEO-1'
• Predicates are modeled as Boolean expressions over a fact base
• Supports temporal conditions: effective dates, deadlines, and sunset provisions

This allows the graph to dynamically activate or deactivate duties based on a changing factual context, enabling real-time compliance assessment.

Obligation Graphs are populated through normative parsing, a specialized NLP task that extracts deontic structures from unstructured legal text.

• Identifies the actor (subject), action (verb phrase), and modality (must, shall, may, may not)
• Resolves definitional cross-references to normalize entity names
• Handles exception handling logic by creating negative conditions on obligation edges

The extraction pipeline typically uses fine-tuned legal language models trained on annotated statutes and regulations.

Once constructed, the Obligation Graph enables automated normative conflict detection and regulatory gap analysis.

• Conflict Detection: Identifies when an action is simultaneously labeled as obligatory and prohibited for the same actor
• Gap Analysis: Surfaces factual scenarios where no explicit obligation, permission, or prohibition exists
• Hierarchy Resolution: Uses statutory hierarchy modeling to resolve conflicts between overlapping obligations from different sources of authority

These capabilities are critical for building coherent, contradiction-free compliance reasoning systems.

The graph supports complex graph traversal queries to answer legal compliance questions.

• Forward traversal: 'Given Actor X, what are all of their obligations?'
• Backward traversal: 'What conditions trigger a duty to file Form 10-K?'
• Path queries: 'What chain of obligations links a manufacturer to an end-consumer reporting duty?'

Implemented using graph databases like Neo4j with Cypher or RDF triplestores with SPARQL, these queries power downstream Legal Syllogism Engines that bind rules to facts.

The formal modal logic that provides the mathematical foundation for obligation graphs. Deontic logic extends classical logic with operators for obligation (O), permission (P), and prohibition (F). In an obligation graph, each directed edge represents an instantiated deontic operator—specifically, an O(A, φ) statement meaning 'Actor A is obligated to bring about state φ.' The logic's axiomatic system (typically Standard Deontic Logic or SDL) governs how obligations propagate, conflict, and interact with permissions. Key challenges include the paradox of contrary-to-duty obligations and the Ross paradox, both of which must be addressed for the graph to model real-world legal reasoning without generating spurious or contradictory duties.

The NLP pipeline that extracts the raw material for obligation graphs from unstructured statutory text. Normative parsing decomposes legal sentences into their deontic components: the actor (who bears the duty), the action (what must be done), the modality (obligation, permission, or prohibition), and the condition (under what circumstances). For example, parsing 'An employer shall, within 30 days of hire, verify employment eligibility' yields:

• Actor: employer
• Action: verify employment eligibility
• Modality: obligation
• Temporal constraint: within 30 days of hire This structured output directly populates the nodes and labeled edges of the obligation graph.

The algorithmic process of identifying contradictory deontic statements that would corrupt an obligation graph's logical consistency. A conflict arises when the same action is simultaneously classified as both obligatory and prohibited, or when an obligation conflicts with a permission not to act. Detection algorithms traverse the graph to find paths where:

• O(A, φ) and F(A, φ) coexist
• O(A, φ) and P(A, ¬φ) coexist Resolution strategies include lex specialis (specific rules override general ones), temporal priority (later-enacted laws prevail), and hierarchical superiority (constitutional norms override statutory ones). Without robust conflict detection, an obligation graph cannot serve as a reliable compliance engine.

The complementary knowledge graph to the obligation graph, representing discretionary rights rather than mandatory duties. Where an obligation graph edge encodes 'Actor A must perform action X,' a permission graph edge encodes 'Actor A may perform action X.' The two graphs must be co-analyzed because:

• A permission can act as an exception to a general obligation
• The absence of a permission does not imply a prohibition
• Permissions often define the scope of lawful discretion within which an obligated actor must operate In computational legal reasoning, querying both graphs simultaneously prevents false-positive violation flags when an action is permitted but not mandated.

The directed knowledge graph representing actions that are legally forbidden, forming the third pillar of the deontic graph triad alongside obligation and permission graphs. A prohibition graph edge encodes 'Actor A is forbidden from performing action X,' which is logically equivalent to O(A, ¬X)—an obligation to refrain. Prohibition graphs are critical for:

• Compliance checking: identifying when a proposed action traverses a forbidden edge
• Exception modeling: many obligations are phrased as 'Do X, unless Y is prohibited'
• Penalty attachment: prohibition edges often carry associated sanction nodes specifying the legal consequence of violation The three graphs together form a complete deontic knowledge base for automated legal reasoning.

The computational mechanism that instantiates an abstract obligation graph against a concrete factual scenario to generate actionable legal conclusions. The process involves:

• Predicate matching: mapping the conditional triggers on graph edges (e.g., 'if the employee is a minor') to verified facts in a case record
• Entity resolution: binding graph nodes representing generic actors (e.g., 'the employer') to specific real-world entities (e.g., 'Acme Corp')
• Temporal grounding: anchoring time-bound obligations to actual calendar dates Successful rule-to-fact binding transforms the obligation graph from a static representation of the law into a dynamic compliance engine that can answer the question: 'Given these facts, what must this specific actor do right now?'