eyeprolog 1.3.20 → 1.3.21

package/examples/odrl-policy-reasoning.pl

@@ -0,0 +1,411 @@
+% ODRL-style policy reasoning in plain EyeProlog.
+%
+% This executable example models the reasoning layer rather than JSON-LD
+% parsing.  It covers ODRL 2.2 permissions, prohibitions, constraints, duties,
+% the perm/prohibit/invalid conflict strategies, action dependencies, and
+% subsumption questions.  The final section shows how an ODRL profile with
+% recursive defaults can use tnot/1: WFS keeps a negative cycle undefined
+% instead of choosing an arbitrary permission or prohibition.
+%
+% References: https://www.w3.org/TR/odrl-model/#conflict
+%             https://w3c.github.io/odrl/formal-semantics/
+
+%% goal: actionQuestion(X0, X1, X2, X3)
+%% goal: ruleQuestion(X0, X1, X2, X3)
+%% goal: enforcementQuestion(X0, X1, X2, X3, X4, X5)
+%% goal: conflictQuestion(X0, X1, X2, X3, X4)
+%% goal: subsumptionQuestion(X0, X1, X2, X3)
+%% goal: wfsQuestion(X0, X1)
+
+% --- ODRL action vocabulary -----------------------------------------------
+
+% A small excerpt of the ODRL action hierarchy.  broader(A, B) means that A
+% is the more general action.  For example, a rule about use can affect print.
+action(use).
+action(present).
+action(display).
+action(play).
+action(print).
+action(distribute).
+action(reproduce).
+action(aggregate).
+action(extract).
+action(read).
+action(delete).
+
+broader(use, present).
+broader(present, display).
+broader(present, play).
+broader(use, print).
+broader(use, distribute).
+broader(use, reproduce).
+
+% Implicit action dependencies are kept separate from explicit subsumption.
+requires(aggregate, read).
+requires(extract, read).
+
+action_subsumes(Action, Action) :- action(Action).
+action_subsumes(Broader, Narrower) :- broader(Broader, Narrower).
+action_subsumes(Broader, Narrower) :-
+  broader(Broader, Middle),
+  action_subsumes(Middle, Narrower).
+
+action_requires(Action, Required) :- requires(Action, Required).
+action_requires(Action, Required) :-
+  requires(Action, Middle),
+  action_requires(Middle, Required).
+
+% The six useful answers to "how does this rule action relate to the requested
+% action?": exact, broader, narrower, required, requiring, or no_match.
+positive_action_match(Action, Action, exact) :- action(Action).
+positive_action_match(RuleAction, RequestAction, broader) :-
+  RuleAction \= RequestAction,
+  action_subsumes(RuleAction, RequestAction).
+positive_action_match(RuleAction, RequestAction, narrower) :-
+  RuleAction \= RequestAction,
+  action_subsumes(RequestAction, RuleAction).
+positive_action_match(RuleAction, RequestAction, required) :-
+  action_requires(RequestAction, RuleAction).
+positive_action_match(RuleAction, RequestAction, requiring) :-
+  action_requires(RuleAction, RequestAction).
+
+action_match(RuleAction, RequestAction, Kind) :-
+  positive_action_match(RuleAction, RequestAction, Kind).
+action_match(RuleAction, RequestAction, no_match) :-
+  action(RuleAction),
+  action(RequestAction),
+  \+ positive_action_match(RuleAction, RequestAction, _).
+
+% --- Parties and assets ----------------------------------------------------
+
+party(alice).
+party(bob).
+party(analysts).
+party(anyone).
+member_of(alice, analysts).
+member_of(bob, analysts).
+
+party_subsumes(Party, Party) :- party(Party).
+party_subsumes(Group, Person) :- member_of(Person, Group).
+party_subsumes(anyone, Party) :- party(Party), Party \= anyone.
+
+asset(report_q1).
+asset(report_q2).
+asset(reports).
+asset(dataset_a).
+asset(dataset_b).
+asset(dataset_c).
+
+asset_member(report_q1, reports).
+asset_member(report_q2, reports).
+
+asset_subsumes(Asset, Asset) :- asset(Asset).
+asset_subsumes(Collection, Item) :- asset_member(Item, Collection).
+
+% --- Policies, rules, requests, and evidence ------------------------------
+
+% policy(Policy, ConflictStrategy).
+policy(open_printing, perm).
+policy(strict_printing, prohibit).
+policy(invalid_printing, invalid).
+policy(duty_policy, invalid).
+policy(context_policy, invalid).
+policy(analysis_policy, invalid).
+policy(general_policy, invalid).
+policy(specific_policy, invalid).
+
+% permission/prohibition(Policy, Rule, Assignee, Action, Target).
+permission(open_printing, open_use, analysts, use, reports).
+prohibition(open_printing, open_no_print, alice, print, report_q1).
+
+permission(strict_printing, strict_use, analysts, use, reports).
+prohibition(strict_printing, strict_no_print, alice, print, report_q1).
+
+permission(invalid_printing, invalid_use, analysts, use, reports).
+prohibition(invalid_printing, invalid_no_print, alice, print, report_q1).
+
+permission(duty_policy, share_report, alice, distribute, report_q1).
+duty(share_report, attribute_source).
+
+permission(context_policy, research_use, analysts, use, reports).
+constraint(research_use, purpose, research).
+
+% Three independent static conflicts: exact action, explicit action
+% subsumption, and an implicit requires dependency.
+permission(analysis_policy, exact_permit, alice, display, dataset_a).
+prohibition(analysis_policy, exact_prohibit, alice, display, dataset_a).
+permission(analysis_policy, broad_permit, alice, use, dataset_b).
+prohibition(analysis_policy, narrow_prohibit, alice, print, dataset_b).
+permission(analysis_policy, aggregate_permit, alice, aggregate, dataset_c).
+prohibition(analysis_policy, read_prohibit, alice, read, dataset_c).
+
+% A broad policy and a narrower policy for rule/policy subsumption questions.
+permission(general_policy, general_use, analysts, use, reports).
+permission(specific_policy, specific_display, alice, display, report_q1).
+constraint(specific_display, purpose, research).
+
+% request(Request, Assignee, Action, Target).
+request(q_print, alice, print, report_q1).
+request(q_share_done, alice, distribute, report_q1).
+request(q_share_missing, alice, distribute, report_q1).
+request(q_research, alice, display, report_q1).
+request(q_commercial, alice, display, report_q1).
+request(q_unrelated, alice, delete, report_q1).
+
+evidence(q_research, purpose, research).
+evidence(q_commercial, purpose, commercial).
+duty_done(q_share_done, attribute_source).
+
+rule(Rule, Policy, permission, Party, Action, Target) :-
+  permission(Policy, Rule, Party, Action, Target).
+rule(Rule, Policy, prohibition, Party, Action, Target) :-
+  prohibition(Policy, Rule, Party, Action, Target).
+
+% --- Rule evaluation -------------------------------------------------------
+
+rule_scope_matches(Rule, Request) :-
+  rule(Rule, _, _, RuleParty, RuleAction, RuleTarget),
+  request(Request, Party, Action, Target),
+  party_subsumes(RuleParty, Party),
+  asset_subsumes(RuleTarget, Target),
+  positive_action_match(RuleAction, Action, _).
+
+constraints_hold(Rule, Request) :-
+  \+ (constraint(Rule, Key, Value), \+ evidence(Request, Key, Value)).
+
+duties_hold(Rule, Request) :-
+  \+ (duty(Rule, Duty), \+ duty_done(Request, Duty)).
+
+permission_result(Rule, Request, permission) :-
+  permission(_, Rule, _, _, _),
+  rule_scope_matches(Rule, Request),
+  constraints_hold(Rule, Request),
+  duties_hold(Rule, Request).
+permission_result(Rule, Request, inactive(constraint(Key))) :-
+  permission(_, Rule, _, _, _),
+  rule_scope_matches(Rule, Request),
+  constraint(Rule, Key, Value),
+  \+ evidence(Request, Key, Value).
+permission_result(Rule, Request, inactive(duty(Duty))) :-
+  permission(_, Rule, _, _, _),
+  rule_scope_matches(Rule, Request),
+  constraints_hold(Rule, Request),
+  duty(Rule, Duty),
+  \+ duty_done(Request, Duty).
+permission_result(Rule, Request, not_applicable) :-
+  permission(_, Rule, _, _, _),
+  \+ rule_scope_matches(Rule, Request).
+
+prohibition_result(Rule, Request, prohibition) :-
+  prohibition(_, Rule, _, _, _),
+  rule_scope_matches(Rule, Request),
+  constraints_hold(Rule, Request).
+prohibition_result(Rule, Request, inactive(constraint(Key))) :-
+  prohibition(_, Rule, _, _, _),
+  rule_scope_matches(Rule, Request),
+  constraint(Rule, Key, Value),
+  \+ evidence(Request, Key, Value).
+prohibition_result(Rule, Request, not_applicable) :-
+  prohibition(_, Rule, _, _, _),
+  \+ rule_scope_matches(Rule, Request).
+
+rule_result(Rule, Request, Result) :- permission_result(Rule, Request, Result).
+rule_result(Rule, Request, Result) :- prohibition_result(Rule, Request, Result).
+
+% --- Enforcement -----------------------------------------------------------
+
+policy_permission(Policy, Request) :-
+  permission(Policy, Rule, _, _, _),
+  permission_result(Rule, Request, permission).
+policy_prohibition(Policy, Request) :-
+  prohibition(Policy, Rule, _, _, _),
+  prohibition_result(Rule, Request, prohibition).
+policy_inactive(Policy, Request) :-
+  rule(Rule, Policy, _, _, _, _),
+  rule_result(Rule, Request, inactive(_)).
+policy_applicable(Policy, Request) :-
+  rule(Rule, Policy, _, _, _, _),
+  rule_scope_matches(Rule, Request).
+
+% Conflicting permission/prohibition answers use the ODRL conflict strategy.
+policy_result(Policy, Request, permission) :-
+  policy_permission(Policy, Request),
+  policy_prohibition(Policy, Request),
+  policy(Policy, perm).
+policy_result(Policy, Request, prohibition) :-
+  policy_permission(Policy, Request),
+  policy_prohibition(Policy, Request),
+  policy(Policy, prohibit).
+policy_result(Policy, Request, invalid) :-
+  policy_permission(Policy, Request),
+  policy_prohibition(Policy, Request),
+  policy(Policy, invalid).
+
+% Non-conflicting active rules retain their deontic result.
+policy_result(Policy, Request, permission) :-
+  policy_permission(Policy, Request),
+  \+ policy_prohibition(Policy, Request).
+policy_result(Policy, Request, prohibition) :-
+  policy_prohibition(Policy, Request),
+  \+ policy_permission(Policy, Request).
+policy_result(Policy, Request, inactive) :-
+  \+ policy_permission(Policy, Request),
+  \+ policy_prohibition(Policy, Request),
+  policy_inactive(Policy, Request).
+policy_result(Policy, Request, not_applicable) :-
+  policy(Policy, _),
+  \+ policy_applicable(Policy, Request).
+
+% Access-control enforcement adds the evaluator behaviour for the case where
+% no rule applies.  "default" is the ODRL evaluator's closed behaviour.
+access_decision(Policy, Request, _Behaviour, permit) :-
+  policy_result(Policy, Request, permission).
+access_decision(Policy, Request, _Behaviour, deny) :-
+  policy_result(Policy, Request, prohibition).
+access_decision(Policy, Request, _Behaviour, invalid) :-
+  policy_result(Policy, Request, invalid).
+access_decision(Policy, Request, _Behaviour, deny) :-
+  policy_result(Policy, Request, inactive).
+access_decision(Policy, Request, open, permit) :-
+  policy_result(Policy, Request, not_applicable).
+access_decision(Policy, Request, closed, deny) :-
+  policy_result(Policy, Request, not_applicable).
+access_decision(Policy, Request, default, deny) :-
+  policy_result(Policy, Request, not_applicable).
+
+% --- Static conflict detection --------------------------------------------
+
+opposite(permission, prohibition).
+opposite(prohibition, permission).
+
+parties_overlap(A, B) :- party_subsumes(A, B).
+parties_overlap(A, B) :- party_subsumes(B, A).
+assets_overlap(A, B) :- asset_subsumes(A, B).
+assets_overlap(A, B) :- asset_subsumes(B, A).
+constraints_compatible(RuleA, RuleB) :-
+  \+ (constraint(RuleA, Key, A), constraint(RuleB, Key, B), A \= B).
+
+conflicting_action(Action, Action, exact) :- action(Action).
+conflicting_action(ActionA, ActionB, subsumption) :-
+  ActionA \= ActionB,
+  (action_subsumes(ActionA, ActionB); action_subsumes(ActionB, ActionA)).
+conflicting_action(ActionA, ActionB, dependency) :-
+  \+ action_subsumes(ActionA, ActionB),
+  \+ action_subsumes(ActionB, ActionA),
+  (action_requires(ActionA, ActionB); action_requires(ActionB, ActionA)).
+
+rule_conflict(RuleA, RuleB, Kind) :-
+  rule(RuleA, _, EffectA, PartyA, ActionA, TargetA),
+  rule(RuleB, _, EffectB, PartyB, ActionB, TargetB),
+  opposite(EffectA, EffectB),
+  parties_overlap(PartyA, PartyB),
+  assets_overlap(TargetA, TargetB),
+  constraints_compatible(RuleA, RuleB),
+  conflicting_action(ActionA, ActionB, Kind).
+
+% --- Rule and policy subsumption ------------------------------------------
+
+constraints_subsume(General, Specific) :-
+  \+ (constraint(General, Key, Value), \+ constraint(Specific, Key, Value)).
+duties_subsume(General, Specific) :-
+  \+ (duty(General, Duty), \+ duty(Specific, Duty)).
+
+rule_subsumes(General, Specific) :-
+  rule(General, _, Effect, GeneralParty, GeneralAction, GeneralTarget),
+  rule(Specific, _, Effect, SpecificParty, SpecificAction, SpecificTarget),
+  party_subsumes(GeneralParty, SpecificParty),
+  action_subsumes(GeneralAction, SpecificAction),
+  asset_subsumes(GeneralTarget, SpecificTarget),
+  constraints_subsume(General, Specific),
+  duties_subsume(General, Specific).
+
+policy_subsumes(General, Specific) :-
+  policy(General, _),
+  policy(Specific, _),
+  \+ (rule(SpecificRule, Specific, _, _, _, _),
+      \+ (rule(GeneralRule, General, _, _, _, _),
+          rule_subsumes(GeneralRule, SpecificRule))).
+
+% --- WFS: true, false, and undefined --------------------------------------
+
+% A profile can add recursive default rules.  clear is unconditionally allowed,
+% denied has no permission, and cycle has mutually defaulted permission and
+% prohibition.  The last case is intentionally undefined under WFS.
+profile_request(clear).
+profile_request(denied).
+profile_request(cycle).
+cycle_request(cycle).
+
+profile_permission(clear).
+profile_permission(Request) :-
+  cycle_request(Request),
+  tnot(profile_prohibition(Request)).
+profile_prohibition(denied).
+profile_prohibition(Request) :-
+  cycle_request(Request),
+  tnot(profile_permission(Request)).
+
+% For a ground WFS claim, both Claim and tnot(Claim) conditionally succeed when
+% the truth value is undefined.  That lets this example expose all three states.
+wfs_truth(Claim, true) :- call(Claim), \+ tnot(Claim).
+wfs_truth(Claim, false) :- tnot(Claim), \+ call(Claim).
+wfs_truth(Claim, undefined) :- call(Claim), tnot(Claim).
+
+% --- Curated questions -----------------------------------------------------
+
+% All six action relationship outcomes used by the evaluator.
+actionQuestion(exact, use, use, Kind) :- action_match(use, use, Kind).
+actionQuestion(broader, use, print, Kind) :- action_match(use, print, Kind).
+actionQuestion(narrower, print, use, Kind) :- action_match(print, use, Kind).
+actionQuestion(required, read, aggregate, Kind) :- action_match(read, aggregate, Kind).
+actionQuestion(requiring, aggregate, read, Kind) :- action_match(aggregate, read, Kind).
+actionQuestion(unrelated, display, delete, Kind) :- action_match(display, delete, Kind).
+
+% Rule-level evaluation shows active permission/prohibition, inactive rules
+% caused by a failed condition or constraint, and non-applicability.
+ruleQuestion(unconditional, open_use, q_print, Result) :- rule_result(open_use, q_print, Result).
+ruleQuestion(duty_satisfied, share_report, q_share_done, Result) :- rule_result(share_report, q_share_done, Result).
+ruleQuestion(duty_missing, share_report, q_share_missing, Result) :- rule_result(share_report, q_share_missing, Result).
+ruleQuestion(constraint_true, research_use, q_research, Result) :- rule_result(research_use, q_research, Result).
+ruleQuestion(constraint_false, research_use, q_commercial, Result) :- rule_result(research_use, q_commercial, Result).
+ruleQuestion(scope_miss, research_use, q_unrelated, Result) :- rule_result(research_use, q_unrelated, Result).
+ruleQuestion(prohibition, open_no_print, q_print, Result) :- rule_result(open_no_print, q_print, Result).
+
+% The same conflicting request under all three ODRL conflict strategies, then
+% duty/constraint failures and open-vs-closed handling when no rule applies.
+enforcementQuestion(permission_overrides, open_printing, q_print, closed, Result, Decision) :-
+  policy_result(open_printing, q_print, Result), access_decision(open_printing, q_print, closed, Decision).
+enforcementQuestion(prohibition_overrides, strict_printing, q_print, closed, Result, Decision) :-
+  policy_result(strict_printing, q_print, Result), access_decision(strict_printing, q_print, closed, Decision).
+enforcementQuestion(conflict_invalidates, invalid_printing, q_print, closed, Result, Decision) :-
+  policy_result(invalid_printing, q_print, Result), access_decision(invalid_printing, q_print, closed, Decision).
+enforcementQuestion(duty_satisfied, duty_policy, q_share_done, closed, Result, Decision) :-
+  policy_result(duty_policy, q_share_done, Result), access_decision(duty_policy, q_share_done, closed, Decision).
+enforcementQuestion(duty_missing, duty_policy, q_share_missing, closed, Result, Decision) :-
+  policy_result(duty_policy, q_share_missing, Result), access_decision(duty_policy, q_share_missing, closed, Decision).
+enforcementQuestion(constraint_false, context_policy, q_commercial, closed, Result, Decision) :-
+  policy_result(context_policy, q_commercial, Result), access_decision(context_policy, q_commercial, closed, Decision).
+enforcementQuestion(no_match_closed, context_policy, q_unrelated, closed, Result, Decision) :-
+  policy_result(context_policy, q_unrelated, Result), access_decision(context_policy, q_unrelated, closed, Decision).
+enforcementQuestion(no_match_open, context_policy, q_unrelated, open, Result, Decision) :-
+  policy_result(context_policy, q_unrelated, Result), access_decision(context_policy, q_unrelated, open, Decision).
+enforcementQuestion(no_match_default, context_policy, q_unrelated, default, Result, Decision) :-
+  policy_result(context_policy, q_unrelated, Result), access_decision(context_policy, q_unrelated, default, Decision).
+
+% Conflict analysis distinguishes equality, explicit action subsumption, and
+% implicit requires dependencies.
+conflictQuestion(exact, analysis_policy, exact_permit, exact_prohibit, Kind) :- rule_conflict(exact_permit, exact_prohibit, Kind).
+conflictQuestion(subsumption, analysis_policy, broad_permit, narrow_prohibit, Kind) :- rule_conflict(broad_permit, narrow_prohibit, Kind).
+conflictQuestion(dependency, analysis_policy, aggregate_permit, read_prohibit, Kind) :- rule_conflict(aggregate_permit, read_prohibit, Kind).
+
+% Positive and negative action, rule, and whole-policy subsumption questions.
+subsumptionQuestion(action_yes, use, display, yes) :- action_subsumes(use, display).
+subsumptionQuestion(action_no, display, use, no) :- \+ action_subsumes(display, use).
+subsumptionQuestion(rule_yes, general_use, specific_display, yes) :- rule_subsumes(general_use, specific_display).
+subsumptionQuestion(rule_no, specific_display, general_use, no) :- \+ rule_subsumes(specific_display, general_use).
+subsumptionQuestion(policy_yes, general_policy, specific_policy, yes) :- policy_subsumes(general_policy, specific_policy).
+subsumptionQuestion(policy_no, specific_policy, general_policy, no) :- \+ policy_subsumes(specific_policy, general_policy).
+
+wfsQuestion(clear_permission, State) :- wfs_truth(profile_permission(clear), State).
+wfsQuestion(absent_permission, State) :- wfs_truth(profile_permission(denied), State).
+wfsQuestion(negative_cycle, State) :- wfs_truth(profile_permission(cycle), State).

package/examples/output/odrl-policy-reasoning.pl

@@ -0,0 +1,34 @@
+actionQuestion(exact, use, use, exact).
+actionQuestion(broader, use, print, broader).
+actionQuestion(narrower, print, use, narrower).
+actionQuestion(required, read, aggregate, required).
+actionQuestion(requiring, aggregate, read, requiring).
+actionQuestion(unrelated, display, delete, no_match).
+ruleQuestion(unconditional, open_use, q_print, permission).
+ruleQuestion(duty_satisfied, share_report, q_share_done, permission).
+ruleQuestion(duty_missing, share_report, q_share_missing, inactive(duty(attribute_source))).
+ruleQuestion(constraint_true, research_use, q_research, permission).
+ruleQuestion(constraint_false, research_use, q_commercial, inactive(constraint(purpose))).
+ruleQuestion(scope_miss, research_use, q_unrelated, not_applicable).
+ruleQuestion(prohibition, open_no_print, q_print, prohibition).
+enforcementQuestion(permission_overrides, open_printing, q_print, closed, permission, permit).
+enforcementQuestion(prohibition_overrides, strict_printing, q_print, closed, prohibition, deny).
+enforcementQuestion(conflict_invalidates, invalid_printing, q_print, closed, invalid, invalid).
+enforcementQuestion(duty_satisfied, duty_policy, q_share_done, closed, permission, permit).
+enforcementQuestion(duty_missing, duty_policy, q_share_missing, closed, inactive, deny).
+enforcementQuestion(constraint_false, context_policy, q_commercial, closed, inactive, deny).
+enforcementQuestion(no_match_closed, context_policy, q_unrelated, closed, not_applicable, deny).
+enforcementQuestion(no_match_open, context_policy, q_unrelated, open, not_applicable, permit).
+enforcementQuestion(no_match_default, context_policy, q_unrelated, default, not_applicable, deny).
+conflictQuestion(exact, analysis_policy, exact_permit, exact_prohibit, exact).
+conflictQuestion(subsumption, analysis_policy, broad_permit, narrow_prohibit, subsumption).
+conflictQuestion(dependency, analysis_policy, aggregate_permit, read_prohibit, dependency).
+subsumptionQuestion(action_yes, use, display, yes).
+subsumptionQuestion(action_no, display, use, no).
+subsumptionQuestion(rule_yes, general_use, specific_display, yes).
+subsumptionQuestion(rule_no, specific_display, general_use, no).
+subsumptionQuestion(policy_yes, general_policy, specific_policy, yes).
+subsumptionQuestion(policy_no, specific_policy, general_policy, no).
+wfsQuestion(clear_permission, true).
+wfsQuestion(absent_permission, false).
+wfsQuestion(negative_cycle, undefined).

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.3.20",
+  "version": "1.3.21",
   "description": "EyeProlog turns facts and rules into answers and proofs.",
   "type": "module",
   "main": "./index.js",

package/playground.html

@@ -586,6 +586,7 @@
           "odrl-dpv-risk-ranked",
           "odrl-policy",
           "odrl-policy-advanced",
+          "odrl-policy-reasoning",
           "orbital-transfer-design",
           "partial-evaluator",
           "path-discovery",

package/the-art-of-eyeprolog.md

@@ -6951,7 +6951,7 @@ Review questions:
 </figure>
 
 The [examples directory](https://github.com/eyereasoner/eyeprolog/tree/main/examples/) is the book's executable companion. The
-top-level directory contains **210 self-contained runnable programs**. Every
+top-level directory contains **211 self-contained runnable programs**. Every
 source program has an exact answer file under
 [examples/output](https://github.com/eyereasoner/eyeprolog/tree/main/examples/output/), and **61 selected programs** have a checked
 explanation under [examples/proof](https://github.com/eyereasoner/eyeprolog/tree/main/examples/proof/). The thematic tables below link every top-level program and open the program
@@ -7281,6 +7281,7 @@ ground RDF-shaped results that can be serialized back to RDF.
 | [ODRL–DPV consumer risk ranking](https://github.com/eyereasoner/eyeprolog/blob/main/examples/odrl-dpv-risk-ranked.pl) | Score consumer-policy conflicts and return a deterministic risk ranking. | [answers](https://github.com/eyereasoner/eyeprolog/blob/main/examples/output/odrl-dpv-risk-ranked.pl) |
 | [ODRL policy](https://github.com/eyereasoner/eyeprolog/blob/main/examples/odrl-policy.pl) | Read one purpose-constrained permission from an ODRL policy graph. | [answers](https://github.com/eyereasoner/eyeprolog/blob/main/examples/output/odrl-policy.pl) |
 | [Advanced ODRL policy](https://github.com/eyereasoner/eyeprolog/blob/main/examples/odrl-policy-advanced.pl) | Evaluate permission, duty, constraint failure, and prohibition outcomes. | [answers](https://github.com/eyereasoner/eyeprolog/blob/main/examples/output/odrl-policy-advanced.pl) |
+| [ODRL policy reasoning](https://github.com/eyereasoner/eyeprolog/blob/main/examples/odrl-policy-reasoning.pl) | Query action relationships, rule and enforcement outcomes, conflict strategies and kinds, action/rule/policy subsumption, and three-valued WFS defaults. | [answers](https://github.com/eyereasoner/eyeprolog/blob/main/examples/output/odrl-policy-reasoning.pl) |
 | [RDF 1.2 annotated claims](https://github.com/eyereasoner/eyeprolog/blob/main/examples/rdf12-annotated-claims.pl) | Rank conflicting annotated claims by confidence and source trust. | [answers](https://github.com/eyereasoner/eyeprolog/blob/main/examples/output/rdf12-annotated-claims.pl) |
 | [RDF 1.2 annotation](https://github.com/eyereasoner/eyeprolog/blob/main/examples/rdf12-annotation.pl) | Recover an asserted triple together with its reifier and annotations. | [answers](https://github.com/eyereasoner/eyeprolog/blob/main/examples/output/rdf12-annotation.pl) |
 | [RDF 1.2 directional language](https://github.com/eyereasoner/eyeprolog/blob/main/examples/rdf12-directional-language.pl) | Preserve language and base-direction metadata in derived labels. | [answers](https://github.com/eyereasoner/eyeprolog/blob/main/examples/output/rdf12-directional-language.pl) |