eyeprolog 1.3.20 → 1.3.22

package/examples/deck/odrl-policy-reasoning.md

@@ -0,0 +1,270 @@
+# ODRL policy reasoning
+
+## One reasoner, many kinds of policy questions
+
+A policy system rarely needs to answer only one question.
+
+It may need to decide whether an action is allowed, detect contradictory rules,
+compare a specific rule with a more general one, or admit that the available
+rules do not determine a unique answer.
+
+The `odrl-policy-reasoning.pl` example shows how those questions can live in
+one executable logical model.
+
+[Run the example in the EyeProlog playground](https://eyereasoner.github.io/eyeprolog/playground#example=odrl-policy-reasoning)
+
+---
+
+# The problem is bigger than permit or deny
+
+A realistic policy engine may be asked:
+
+- **Enforcement:** may Alice print this report?
+- **Conditions:** does the permission apply only for research use?
+- **Duties:** is attribution required before distribution is allowed?
+- **Conflicts:** what if one rule permits an action and another prohibits it?
+- **Subsumption:** does a broad policy already cover a narrower policy?
+- **Incomplete information:** can the rules justify a definite answer at all?
+
+These are different questions, but they are questions about the same policy
+model.
+
+---
+
+# One small policy world
+
+The example contains:
+
+- parties such as `alice`, `bob`, `analysts`, and `anyone`;
+- assets such as reports and datasets;
+- actions such as `use`, `display`, `print`, `read`, and `aggregate`;
+- permissions and prohibitions;
+- constraints and duties;
+- requests asking whether a concrete action may be performed.
+
+For example, a policy can permit analysts to `use` reports while separately
+prohibiting Alice from `print`ing one particular report.
+
+That is enough to create a genuine policy conflict.
+
+---
+
+# Actions are related, not isolated
+
+Policy actions can stand in several useful relationships.
+
+```prolog
+broader(use, present).
+broader(present, display).
+broader(use, print).
+
+requires(aggregate, read).
+```
+
+So a rule about `use` can also be relevant to a request to `display` or
+`print`, while `aggregate` may depend on `read` even though neither action is a
+specialization of the other.
+
+The example can therefore answer six kinds of action-matching question:
+
+`exact`, `broader`, `narrower`, `required`, `requiring`, and `no_match`.
+
+---
+
+# Rules can be active, inactive, or irrelevant
+
+A rule does not automatically apply just because its action looks similar to
+the requested action.
+
+The reasoner also checks the party, asset, constraints, and duties.
+
+For example:
+
+```prolog
+permission(context_policy, research_use, analysts, use, reports).
+constraint(research_use, purpose, research).
+```
+
+A research request can activate this permission. A commercial request reaches
+the same rule but fails its constraint, so the rule is **inactive**. A request
+for an unrelated action is simply **not applicable**.
+
+This distinction matters: "the rule applies but its condition failed" is not
+the same as "this rule has nothing to say about the request".
+
+---
+
+# Enforcement combines the applicable rules
+
+Once individual rules have been evaluated, the policy can answer the practical
+question: what should the system do?
+
+The example demonstrates:
+
+- an active permission becoming `permit`;
+- an active prohibition becoming `deny`;
+- a failed duty or constraint becoming `deny` in the closed evaluator;
+- an unmatched request being permitted by an `open` evaluator;
+- the same unmatched request being denied by `closed` or `default` behaviour.
+
+So enforcement is built from the same rule facts used by the other reasoning
+questions rather than being a separate policy representation.
+
+---
+
+# Conflicting rules need a policy decision
+
+Suppose a request matches both a permission and a prohibition.
+
+The example runs the same kind of conflict under all three ODRL conflict
+strategies:
+
+- `perm` — the permission wins;
+- `prohibit` — the prohibition wins;
+- `invalid` — the conflict invalidates the result.
+
+This keeps **detecting a conflict** separate from **deciding what a policy does
+with that conflict**.
+
+That separation is useful because different policies may deliberately resolve
+the same logical conflict in different ways.
+
+---
+
+# Conflicts can be indirect
+
+Two rules do not need to mention exactly the same action to interfere with one
+another.
+
+The example detects three forms:
+
+1. **Exact conflict** — permission and prohibition concern the same action.
+2. **Subsumption conflict** — a broad permission such as `use` overlaps a
+   narrower prohibition such as `print`.
+3. **Dependency conflict** — a permitted action such as `aggregate` requires
+   another action such as `read`, while `read` is prohibited.
+
+This is why an action model is important: looking only for identical action
+names would miss meaningful policy conflicts.
+
+---
+
+# Subsumption asks "does this already cover that?"
+
+Subsumption turns policy comparison into another executable query.
+
+At the action level:
+
+```prolog
+?- action_subsumes(use, display).
+true.
+```
+
+At the rule level, the comparison also takes parties, assets, constraints, and
+duties into account.
+
+At the policy level, the reasoner asks whether every rule in a more specific
+policy is covered by some rule in the more general policy.
+
+This supports questions such as:
+
+> Does policy A already express everything required by policy B?
+
+The example contains both positive and negative cases for action, rule, and
+whole-policy subsumption.
+
+---
+
+# Sometimes "yes or no" is the wrong choice
+
+Rule systems can contain recursion through negation.
+
+In simplified form:
+
+```prolog
+permission(X) :- tnot(prohibition(X)).
+prohibition(X) :- tnot(permission(X)).
+```
+
+For a request caught in this negative cycle, arbitrarily choosing one side
+would invent information that the rules do not justify.
+
+EyeProlog uses **Well-Founded Semantics (WFS)**, which has three truth states:
+
+- **true** — the claim can be established;
+- **false** — its negation can be established;
+- **undefined** — neither side is justified because the reasoning is cyclic.
+
+---
+
+# Undefined is useful information
+
+The example deliberately asks three WFS questions:
+
+```text
+clear_permission  -> true
+absent_permission -> false
+negative_cycle    -> undefined
+```
+
+`undefined` is not an error and it is not a random third answer.
+
+It tells the application that the policy knowledge itself does not determine a
+stable true/false conclusion.
+
+An enforcement layer can then choose how to handle that uncertainty — for
+example by denying conservatively, asking for more information, or escalating
+for review — without corrupting the logical result.
+
+---
+
+# Why put these questions in one reasoner?
+
+A mixed *reasoning* approach can still have a single declarative home.
+
+The example uses different logical capabilities where they fit:
+
+- hierarchy and transitive reasoning for action relationships;
+- ordinary rules for applicability and enforcement;
+- structural reasoning for conflict detection and subsumption;
+- negation and WFS for recursive defaults and incomplete conclusions.
+
+They are not forced into one algorithm. They coexist behind one language, one
+knowledge model, and one query mechanism.
+
+That is the sense in which EyeProlog can be **"a reasoner to run them all."**
+
+---
+
+# What this example is — and is not
+
+`odrl-policy-reasoning.pl` demonstrates the **reasoning layer** in plain
+EyeProlog.
+
+It is not intended to be a complete ODRL JSON-LD parser or a replacement for
+the full ODRL information model. Other repository examples demonstrate RDF and
+ODRL data handling.
+
+Its purpose is narrower and practical: show that enforcement, conflict
+analysis, subsumption, dependencies, constraints, duties, and three-valued WFS
+reasoning can be queried coherently in one executable model.
+
+---
+
+# Try it yourself
+
+Run the example in the browser:
+
+**https://eyereasoner.github.io/eyeprolog/playground#example=odrl-policy-reasoning**
+
+Then change one fact at a time:
+
+- fulfil or remove a duty;
+- change `research` to `commercial`;
+- add or remove an action hierarchy edge;
+- introduce a new prohibition;
+- change the policy conflict strategy;
+- create or break a negative cycle.
+
+Then observe which enforcement, conflict, subsumption, and WFS answers change
+together.

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.22",
   "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) |