LegalRuleML

Encodes legal norms using formal deontic operators—obligation, permission, and prohibition—rather than relying on ambiguous natural language. This allows machines to unambiguously interpret whether an action is mandatory, permissible, or forbidden.

• Maps directly to Standard Deontic Logic (SDL) and Input/Output Logic
• Distinguishes between regulative norms (governing conduct) and constitutive norms (defining legal facts)
• Supports Hohfeldian jural correlatives to disambiguate normative positions between parties

Models legal rules as defeasible—admitting exceptions and capable of being overridden by stronger counter-arguments. This reflects the reality that legal conclusions are rarely absolute.

• Implements non-monotonic logic where conclusions can be retracted with new evidence
• Handles normative conflict resolution via priority rules like lex superior and lex specialis
• Enables encoding of contrary-to-duty (CTD) obligations that activate when primary duties are violated

Annotates rules with temporal parameters (effective dates, repeal dates) and jurisdictional scope to ensure correct applicability. A rule is only triggered when its temporal and spatial conditions are satisfied.

• Models dynamic obligations that change as time progresses
• Associates rules with specific legal authorities and jurisdictions
• Enables cross-jurisdictional harmonization by explicitly tagging the sovereign source of each norm

Provides a standardized XML schema for serializing legal rules, enabling seamless exchange between different legal reasoning engines, compliance checkers, and document analysis pipelines.

• Built on RuleML foundations, extending it with legal-specific constructs
• Integrates with Akoma Ntoso for legislative document markup
• Enables deontic smart contracts by exporting computable normative clauses to executable environments

Serves as the formal backbone for normative compliance checkers that evaluate agent actions against encoded rules. A trace of events can be algorithmically verified against a LegalRuleML knowledge base to detect violations.

• Supports deontic event calculus for tracking obligation lifecycles (activation, fulfillment, violation, expiration)
• Enables automated violation detection and sanction triggering
• Integrates with SHACL and XACML profiles for enterprise policy enforcement

Attaches rich metadata to each rule, including its source document, enacting authority, and interpretive history. This ensures citation integrity and auditability in automated reasoning chains.

• Links rules to their legislative source via persistent identifiers
• Tracks amendments and repeals to maintain an accurate normative state
• Supports normative faithfulness metrics by providing ground-truth references for evaluating AI-generated legal reasoning

The formal logical foundation upon which LegalRuleML's semantics are built. It extends classical logic with operators for obligation (O) and permission (P).

• Models ideal normative states, not actual facts
• Provides the axiomatic basis for the obligation and permission elements in LegalRuleML
• Standard system (SDL) uses a normal modal logic (KD) to avoid obligating contradictions

A conditional obligation triggered by the violation of a primary duty. LegalRuleML's penalty and reparation structures are explicitly designed to model CTD scenarios.

• Example: 'You ought not to cause damage; but if you do, you ought to repair it'
• Resolves the temporal and conditional nature of fallback norms
• Critical for encoding realistic legal codes that anticipate non-compliance

A non-monotonic logic that allows conclusions to be retracted when new evidence or higher-priority rules apply. This directly supports LegalRuleML's strength and priority attributes.

• Models how legal rules admit exceptions without collapsing into contradiction
• Enables the defeasibleStrength attribute to mark rules as overridable
• Implements principles like lex specialis (specific law prevails) in the reasoning engine

A fundamental analytical framework decomposing legal relations into eight jural correlatives. LegalRuleML uses this to disambiguate normative positions between parties.

• Right/Duty: One party's claim correlates to another's obligation
• Privilege/No-Right: Freedom from a duty for one party
• Power/Liability: Ability to change a legal relation
• Immunity/Disability: Freedom from having one's legal relation changed

An architecture where autonomous agents are governed by explicit norms. LegalRuleML provides the normative specification language that these agents interpret at runtime.

• Agents check their intended actions against a LegalRuleML rulebase
• Violations trigger sanctioning mechanisms encoded as reparation chains
• Enables distributed regulatory compliance in autonomous systems like smart contracts and robotic process automation

A computable contract that formally encodes obligations, permissions, and prohibitions as executable code. LegalRuleML serves as the human-readable, legally-grounded source that compiles to smart contract logic.

• Bridges legal prose and deterministic execution on distributed ledgers
• Uses LegalRuleML's penalty elements to define automated remedial actions
• Ensures the code reflects the normative intent of the legal drafter, not just procedural logic