eyeprolog 0.5.3

package/examples/hamming-code.pl

@@ -0,0 +1,115 @@
+% Technology example: Hamming(7,4) single-bit error correction.
+%
+% The received word has one corrupted bit. Syndrome bits identify the bad
+% position, then the corrected codeword and decoded payload are derived.
+
+% Output declarations: host-supplied goals select the relations written to this example's golden output.
+%
+% Positions are one-based to match the textbook parity-check layout. The
+% syndrome value is both the error certificate and the index of the bit to fix.
+%% goal: syndrome(X0, X1)
+
+%% goal: errorBit(X0, X1)
+
+%% goal: correctedCodeword(X0, X1)
+
+%% goal: decodedPayload(X0, X1)
+
+%% goal: status(X0, X1)
+
+%% goal: reason(X0, X1)
+
+
+% Program structure: facts set up the scenario, and rules derive the queried conclusions.
+received_bit(packet1, 1, 1).
+received_bit(packet1, 2, 0).
+received_bit(packet1, 3, 1).
+received_bit(packet1, 4, 1).
+received_bit(packet1, 5, 1).
+received_bit(packet1, 6, 1).
+received_bit(packet1, 7, 0).
+
+flip(0, 1).
+flip(1, 0).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+parity4(A, B, C, D, Parity) :-
+  (Ab is A + B),
+  (Abc is Ab + C),
+  (Sum is Abc + D),
+  (Parity is Sum mod 2).
+
+syndrome_bit1(Code, S1) :-
+  received_bit(Code, 1, B1),
+  received_bit(Code, 3, B3),
+  received_bit(Code, 5, B5),
+  received_bit(Code, 7, B7),
+  parity4(B1, B3, B5, B7, S1).
+
+syndrome_bit2(Code, S2) :-
+  received_bit(Code, 2, B2),
+  received_bit(Code, 3, B3),
+  received_bit(Code, 6, B6),
+  received_bit(Code, 7, B7),
+  parity4(B2, B3, B6, B7, S2).
+
+syndrome_bit4(Code, S4) :-
+  received_bit(Code, 4, B4),
+  received_bit(Code, 5, B5),
+  received_bit(Code, 6, B6),
+  received_bit(Code, 7, B7),
+  parity4(B4, B5, B6, B7, S4).
+
+% syndrome/2 combines parity checks as S1 + 2*S2 + 4*S4.
+syndrome(Code, Syndrome) :-
+  syndrome_bit1(Code, S1),
+  syndrome_bit2(Code, S2),
+  syndrome_bit4(Code, S4),
+  (Weighteds2 is S2 * 2),
+  (Weighteds4 is S4 * 4),
+  (Partial is S1 + Weighteds2),
+  (Syndrome is Partial + Weighteds4).
+
+corrected_bit(Code, Position, Corrected) :-
+  syndrome(Code, Position),
+  received_bit(Code, Position, Bit),
+  flip(Bit, Corrected).
+
+corrected_bit(Code, Position, Bit) :-
+  syndrome(Code, Errorposition),
+  (Position \= Errorposition),
+  received_bit(Code, Position, Bit).
+
+corrected_codeword(Code, [B1, B2, B3, B4, B5, B6, B7]) :-
+  corrected_bit(Code, 1, B1),
+  corrected_bit(Code, 2, B2),
+  corrected_bit(Code, 3, B3),
+  corrected_bit(Code, 4, B4),
+  corrected_bit(Code, 5, B5),
+  corrected_bit(Code, 6, B6),
+  corrected_bit(Code, 7, B7).
+
+decoded_payload(Code, [D1, D2, D3, D4]) :-
+  corrected_bit(Code, 3, D1),
+  corrected_bit(Code, 5, D2),
+  corrected_bit(Code, 6, D3),
+  corrected_bit(Code, 7, D4).
+
+
+errorBit(Code, Position) :-
+  syndrome(Code, Position),
+  (Position > 0).
+
+correctedCodeword(Code, Codeword) :-
+  corrected_codeword(Code, Codeword).
+
+decodedPayload(Code, Payload) :-
+  decoded_payload(Code, Payload).
+
+status(Code, single_bit_corrected) :-
+  syndrome(Code, Position),
+  (Position > 0).
+
+reason(Code, "Hamming syndrome identifies the flipped bit position") :-
+  syndrome(Code, Position),
+  (Position > 0).

package/examples/hanoi.pl

@@ -0,0 +1,19 @@
+% Towers of Hanoi adapted from Eyeling hanoi.n3.
+% hanoi/5 recursively builds the move list by moving N-1 disks aside, moving the
+% largest disk, then moving N-1 disks onto the target peg.  The size-3 answer is
+% small enough for a readable golden output while still exercising list append.
+
+%% goal: answer(X0, X1)
+
+
+
+hanoi(0, _from, _to, _via, []).
+hanoi(N, From, To, Via, Moves) :-
+  (N > 0),
+  (N1 is N - 1),
+  hanoi(N1, From, Via, To, Before),
+  hanoi(N1, Via, To, From, After),
+  append(Before, [[From, To]|After], Moves).
+
+answer(3, Moves) :-
+  hanoi(3, left, right, center, Moves).

package/examples/heat-loss.pl

@@ -0,0 +1,61 @@
+% Engineering example: one-dimensional conductive heat loss through a wall.
+%
+% Thermal resistance is L/(k*A), and heat loss is DeltaT/R.  The facts store wall
+% properties as a small attribute table, while rules derive temperature
+% difference, resistance, heat loss, and a qualitative status.
+%
+% Keeping each physical quantity as its own relation makes the proof explanation
+% read like a worked calculation.
+%% goal: type(X0, X1)
+
+%% goal: temperatureDifference_K(X0, X1)
+
+%% goal: thermalResistance_K_W(X0, X1)
+
+%% goal: heatLoss_W(X0, X1)
+
+%% goal: status(X0, X1)
+
+
+% Wall properties are stored as key/value facts: conductivity, area, thickness,
+% and inside/outside temperatures.
+wall(wall1, conductivity_W_mK, 0.8).
+wall(wall1, area_m2, 12.0).
+wall(wall1, thickness_m, 0.2).
+wall(wall1, indoor_C, 21.0).
+wall(wall1, outdoor_C, -4.0).
+
+% The model first derives the temperature difference and thermal resistance,
+% then divides DeltaT by resistance to classify the heat loss.
+temperature_difference(Wall, Deltat) :-
+  wall(Wall, indoor_C, Indoor),
+  wall(Wall, outdoor_C, Outdoor),
+  (Deltat is Indoor - Outdoor).
+
+thermal_resistance(Wall, Resistance) :-
+  wall(Wall, thickness_m, Thickness),
+  wall(Wall, conductivity_W_mK, Conductivity),
+  wall(Wall, area_m2, Area),
+  (Conductance is Conductivity * Area),
+  (Resistance is Thickness / Conductance).
+
+heat_loss(Wall, Heatloss) :-
+  temperature_difference(Wall, Deltat),
+  thermal_resistance(Wall, Resistance),
+  (Heatloss is Deltat / Resistance).
+
+type(Wall, conduction_heat_loss) :-
+  wall(Wall, thickness_m, _thickness).
+
+temperatureDifference_K(Wall, Deltat) :-
+  temperature_difference(Wall, Deltat).
+
+thermalResistance_K_W(Wall, Resistance) :-
+  thermal_resistance(Wall, Resistance).
+
+heatLoss_W(Wall, Heatloss) :-
+  heat_loss(Wall, Heatloss).
+
+status(Wall, high_heat_loss) :-
+  heat_loss(Wall, Heatloss),
+  (Heatloss > 1000.0).

package/examples/herbrand-semantics.pl

@@ -0,0 +1,17 @@
+% Herbrand terms denote themselves: distinct names and constructor applications
+% remain distinct without extra unique-name or free-constructor axioms.
+
+% Output declaration: host-supplied goals select the relation written to this
+% example's golden output.
+%% goal: different(X0, X1)
+
+
+% Under unrestricted Tarskian semantics, alice and bob could denote the same
+% element. In EyeProlog's Herbrand universe, their different syntax is enough.
+different(alice, bob) :-
+  (alice \= bob).
+
+% A general Tarskian function need not be injective. Herbrand compound terms
+% are free constructors, so different arguments produce different terms.
+different(ticket(alice), ticket(bob)) :-
+  (ticket(alice) \= ticket(bob)).

package/examples/herbrand-witnesses.pl

@@ -0,0 +1,35 @@
+% Existential-style consequences as explicit Herbrand witness terms.
+%
+% EyeProlog has no blank nodes and no existential variables in rule heads.  The
+% practical executable form is to put a named functional term directly in the
+% rule head.  The term is ordinary data: stable, visible, and proof-friendly.
+
+%% goal: has_parent(X0, X1)
+
+%% goal: registration(X0, X1, X2)
+
+%% goal: same_witness(X0, X1)
+
+%% goal: distinct_witnesses(X0, X1)
+
+
+person(alice).
+person(bob).
+
+takes(alice, logic).
+takes(alice, math).
+takes(bob, logic).
+
+% One variable: every person has a deterministic parent witness.
+has_parent(Child, parent_of(Child)) :-
+  person(Child).
+
+% Two variables: every student/course pair has its own registration witness.
+registration(Student, Course, registration_of(Student, Course)) :-
+  takes(Student, Course).
+
+same_witness(parent_of_alice, true) :-
+  (parent_of(alice) = parent_of(alice)).
+
+distinct_witnesses(alice_logic_vs_alice_math, true) :-
+  (registration_of(alice, logic) \= registration_of(alice, math)).

package/examples/heron-theorem.pl

@@ -0,0 +1,46 @@
+% Heron's theorem: area = sqrt(s(s-a)(s-b)(s-c)).
+%
+% The sample is the classic 13-14-15 triangle, whose area is exactly 84.  The
+% program querys the semiperimeter, Heron product, and final area so proof
+% output can be checked against the familiar hand calculation.
+%
+% This is a compact example of theorem-shaped arithmetic: facts name a geometric
+% object, reusable relations compute intermediates, and wrapper predicates choose
+% the report vocabulary.
+%% goal: semiperimeter(X0, X1)
+
+%% goal: heronProduct(X0, X1)
+
+%% goal: area(X0, X1)
+
+%% goal: status(X0, X1)
+
+
+% A single survey triangle is enough to demonstrate the formula; 13-14-15 has
+% integer area 84, which makes the computed result easy to check.
+triangle(field_plot, 13, 14, 15).
+
+% semiperimeter/2 is the reusable first step in Heron's formula.
+semiperimeter(Triangle, S) :-
+  triangle(Triangle, A, B, C),
+  (Ab is A + B),
+  (Sum is Ab + C),
+  (S is Sum / 2).
+
+% Area is obtained by taking the square root of this Heron product.
+heron_product(Triangle, Product) :-
+  triangle(Triangle, A, B, C),
+  semiperimeter(Triangle, S),
+  (Sa is S - A),
+  (Sb is S - B),
+  (Sc is S - C),
+  (T1 is S * Sa),
+  (T2 is T1 * Sb),
+  (Product is T2 * Sc).
+
+area(Triangle, Area) :-
+  heron_product(Triangle, Product),
+  (Area is Product ** 0.5).
+
+heronProduct(Triangle, P) :- heron_product(Triangle, P).
+status(Triangle, valid_survey_triangle) :- area(Triangle, A), (A > 0).

package/examples/ideal-gas-law.pl

@@ -0,0 +1,42 @@
+% Science example: ideal gas law.
+%
+% A simple gas cell uses P*V = n*R*T.  The constants are chosen so that the
+% computed pressure is exactly near one atmosphere in this small example.
+
+% Output declarations: host-supplied goals select the relations written to this example's golden output.
+%% goal: pressure_Pa(X0, X1)
+
+%% goal: status(X0, X1)
+
+%% goal: reason(X0, X1)
+
+
+% gas_cell/5 records n, R, T, and V; pressure_limit/3 gives the tolerance band
+% used to classify the result as near atmospheric.
+gas_cell(cell1, 1.0, 8.0, 300.0, 0.024).
+pressure_limit(cell1, low_Pa, 95000.0).
+pressure_limit(cell1, high_Pa, 105000.0).
+
+% pressure/2 computes nRT/V in three explicit arithmetic steps so the proof
+% output exposes numerator construction and final division.
+pressure(Cell, Pressure) :-
+  gas_cell(Cell, Moles, Gasconstant, Temperature, Volume),
+  (Nr is Moles * Gasconstant),
+  (Nrt is Nr * Temperature),
+  (Pressure is Nrt / Volume).
+
+near_atmospheric(Cell) :-
+  pressure(Cell, Pressure),
+  pressure_limit(Cell, low_Pa, Low),
+  pressure_limit(Cell, high_Pa, High),
+  (Pressure > Low),
+  (Pressure < High).
+
+pressure_Pa(Cell, Pressure) :-
+  pressure(Cell, Pressure).
+
+status(Cell, near_atmospheric) :-
+  near_atmospheric(Cell).
+
+reason(Cell, "pressure is inside the one-atmosphere tolerance band") :-
+  near_atmospheric(Cell).

package/examples/illegitimate-reasoning.pl

@@ -0,0 +1,95 @@
+% Illegitimate reasoning detector.
+%
+% The input facts describe arguments and their surface reasoning pattern. Helper
+% predicates identify common invalid inference forms. The output layer emits only
+% concise report relations: the argument is illegitimate, which fallacy was found,
+% the challenged conclusion, and a short reason why.
+
+% Affirming the consequent:
+%   If it rained, the street is wet. The street is wet. Therefore it rained.
+% Output declarations: host-supplied goals select the relations written to this example's golden output.
+%% goal: type(X0, X1)
+
+%% goal: fallacy(X0, X1)
+
+%% goal: conclusion(X0, X1)
+
+%% goal: reason(X0, X1)
+
+%% goal: sampleSize(X0, X1)
+
+%% goal: requiredSampleSize(X0, X1)
+
+%% goal: omittedAlternative(X0, X1)
+
+
+% Program structure: facts set up the scenario, and rules derive the queried conclusions.
+argument(arg_affirming_consequent).
+implication(arg_affirming_consequent, rain, street_wet).
+observed(arg_affirming_consequent, street_wet).
+concludes(arg_affirming_consequent, rain).
+
+% Denying the antecedent:
+%   If the key is present, the door opens. The key is not present. Therefore the door does not open.
+argument(arg_denying_antecedent).
+implication(arg_denying_antecedent, key_present, door_opens).
+observed(arg_denying_antecedent, neg(key_present)).
+concludes(arg_denying_antecedent, neg(door_opens)).
+
+% Hasty generalization:
+%   Three sampled cases are treated as enough for a universal conclusion.
+argument(arg_hasty_generalization).
+sample_size(arg_hasty_generalization, 3).
+required_sample_size(arg_hasty_generalization, 30).
+concludes(arg_hasty_generalization, all(crows, black)).
+
+% False dilemma:
+%   Only two choices are presented even though a relevant third option exists.
+argument(arg_false_dilemma).
+presented_alternatives(arg_false_dilemma, [approve_now, reject_forever]).
+omitted_alternative(arg_false_dilemma, revise_proposal).
+concludes(arg_false_dilemma, approve_now).
+
+% A contrast case: modus ponens is not flagged.
+argument(arg_modus_ponens).
+implication(arg_modus_ponens, subscription_paid, access_allowed).
+observed(arg_modus_ponens, subscription_paid).
+concludes(arg_modus_ponens, access_allowed).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+fallacy(A, affirming_consequent) :-
+  argument(A),
+  implication(A, Antecedent, Consequent),
+  observed(A, Consequent),
+  concludes(A, Antecedent).
+
+fallacy(A, denying_antecedent) :-
+  argument(A),
+  implication(A, Antecedent, Consequent),
+  observed(A, neg(Antecedent)),
+  concludes(A, neg(Consequent)).
+
+fallacy(A, hasty_generalization) :-
+  argument(A),
+  sample_size(A, N),
+  required_sample_size(A, Min),
+  (N < Min),
+  concludes(A, all(_, _)).
+
+fallacy(A, false_dilemma) :-
+  argument(A),
+  presented_alternatives(A, _),
+  omitted_alternative(A, _),
+  concludes(A, _).
+
+reason(arg_affirming_consequent, "observing the consequent does not prove the antecedent").
+reason(arg_denying_antecedent, "denying the antecedent does not disprove the consequent").
+reason(arg_hasty_generalization, "sample size is below the threshold for a universal conclusion").
+reason(arg_false_dilemma, "a relevant alternative is omitted").
+
+type(A, illegitimate_reasoning) :- fallacy(A, _).
+conclusion(A, C) :- fallacy(A, _), concludes(A, C).
+reason(A, R) :- fallacy(A, _), reason(A, R).
+sampleSize(A, N) :- fallacy(A, hasty_generalization), sample_size(A, N).
+requiredSampleSize(A, Min) :- fallacy(A, hasty_generalization), required_sample_size(A, Min).
+omittedAlternative(A, Alt) :- fallacy(A, false_dilemma), omitted_alternative(A, Alt).

package/examples/input/dpv-odrl-purpose-mapping-rules.pl

@@ -0,0 +1,63 @@
+% Source data: examples/input/dpv-odrl-purpose-mapping.ttl
+% Regenerate with:
+% node tools/rdf-to-pl.mjs --rules examples/input/dpv-odrl-purpose-mapping-rules.pl examples/input/dpv-odrl-purpose-mapping.ttl -o examples/dpv-odrl-purpose-mapping.pl
+%
+% The DPV process and ODRL policy are RDF data. The rules verify the six
+% correspondences and return one deterministic mapping report.
+%% goal: dpv_odrl_purpose_mapping(_)
+
+dpv_odrl_purpose_mapping(Mappings) :-
+  findall(
+    mapping(SourceRole, Value, TargetRole),
+    mapped_role(SourceRole, Value, TargetRole),
+    Mappings
+  ).
+
+mapped_role(data_controller, Controller, assigner) :-
+  rdf_link(ex(alpha_care_process), dpv(hasDataController), ex(Controller)),
+  rdf_link(ex(alpha_permission), odrl(assigner), ex(Controller)).
+
+mapped_role(recipient, Recipient, assignee) :-
+  rdf_link(ex(alpha_care_process), dpv(hasRecipient), ex(Recipient)),
+  rdf_link(ex(alpha_permission), odrl(assignee), ex(Recipient)).
+
+mapped_role(personal_data, Data, target) :-
+  rdf_link(ex(alpha_care_process), dpv(hasPersonalData), ex(Data)),
+  rdf_link(ex(alpha_permission), odrl(target), ex(Data)).
+
+mapped_role(processing, dpv_use, action) :-
+  rdf_link(ex(alpha_care_process), dpv(hasProcessing), dpv('Use')),
+  rdf_link(ex(alpha_permission), odrl(action), odrl(use)).
+
+mapped_role(purpose, dpv_healthcare, constraint(alpha_purpose_constraint)) :-
+  rdf_link(ex(alpha_care_process), dpv(hasPurpose), dpv('Healthcare')),
+  odrl_constraint(alpha_purpose_constraint, odrl(purpose), dpv('Healthcare')).
+
+mapped_role(legal_basis, dpv_consent, constraint(alpha_basis_constraint)) :-
+  rdf_link(ex(alpha_care_process), dpv(hasLegalBasis), dpv('Consent')),
+  odrl_constraint(alpha_basis_constraint, ex(legalBasis), dpv('Consent')).
+
+odrl_constraint(Name, LeftOperand, RightOperand) :-
+  rdf_link(ex(alpha_permission), odrl(constraint), ex(Name)),
+  rdf_link(ex(Name), odrl('leftOperand'), LeftOperand),
+  rdf_link(ex(Name), odrl(operator), odrl('isA')),
+  rdf_link(ex(Name), odrl('rightOperand'), RightOperand).
+
+rdf_link(Subject, Predicate, Object) :-
+  iri_term(Subject, SubjectIri),
+  iri_term(Predicate, PredicateIri),
+  rdf(iri(SubjectIri), iri(PredicateIri), iri(ObjectIri), default_graph),
+  iri_term(Object, ObjectIri).
+
+iri_term(ex(Name), Iri) :- namespace_iri("https://example.org/", Name, Iri).
+iri_term(dpv(Name), Iri) :- namespace_iri("https://w3id.org/dpv#", Name, Iri).
+iri_term(odrl(Name), Iri) :- namespace_iri("http://www.w3.org/ns/odrl/2/", Name, Iri).
+
+namespace_iri(Prefix, Name, Iri) :-
+  atom(Name),
+  !,
+  atom_string(Name, Local),
+  string_concat(Prefix, Local, Iri).
+namespace_iri(Prefix, Name, Iri) :-
+  string_concat(Prefix, Local, Iri),
+  atom_string(Name, Local).

package/examples/input/dpv-odrl-purpose-mapping.ttl

@@ -0,0 +1,34 @@
+@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
+@prefix dpv: <https://w3id.org/dpv#> .
+@prefix odrl: <http://www.w3.org/ns/odrl/2/> .
+@prefix ex: <https://example.org/> .
+
+ex:alpha_care_process rdf:type dpv:Process .
+ex:alpha_care_process dpv:hasDataController ex:hospital_a .
+ex:alpha_care_process dpv:hasRecipient ex:research_partner .
+ex:alpha_care_process dpv:hasPersonalData ex:lab_result .
+ex:alpha_care_process dpv:hasProcessing dpv:Use .
+ex:alpha_care_process dpv:hasPurpose dpv:Healthcare .
+ex:alpha_care_process dpv:hasLegalBasis dpv:Consent .
+
+ex:alpha_policy rdf:type odrl:Policy .
+ex:alpha_policy ex:representsProcess ex:alpha_care_process .
+ex:alpha_policy odrl:permission ex:alpha_permission .
+
+ex:alpha_permission rdf:type odrl:Permission .
+ex:alpha_permission odrl:assigner ex:hospital_a .
+ex:alpha_permission odrl:assignee ex:research_partner .
+ex:alpha_permission odrl:target ex:lab_result .
+ex:alpha_permission odrl:action odrl:use .
+ex:alpha_permission odrl:constraint ex:alpha_purpose_constraint .
+ex:alpha_permission odrl:constraint ex:alpha_basis_constraint .
+
+ex:alpha_purpose_constraint rdf:type odrl:Constraint .
+ex:alpha_purpose_constraint odrl:leftOperand odrl:purpose .
+ex:alpha_purpose_constraint odrl:operator odrl:isA .
+ex:alpha_purpose_constraint odrl:rightOperand dpv:Healthcare .
+
+ex:alpha_basis_constraint rdf:type odrl:Constraint .
+ex:alpha_basis_constraint odrl:leftOperand ex:legalBasis .
+ex:alpha_basis_constraint odrl:operator odrl:isA .
+ex:alpha_basis_constraint odrl:rightOperand dpv:Consent .

package/examples/input/odrl-dpv-fpv-trust-flow-rules.pl

@@ -0,0 +1,80 @@
+% Source data: examples/input/odrl-dpv-fpv-trust-flow.ttl
+% Regenerate with:
+% node tools/rdf-to-pl.mjs --rules examples/input/odrl-dpv-fpv-trust-flow-rules.pl examples/input/odrl-dpv-fpv-trust-flow.ttl -o examples/odrl-dpv-fpv-trust-flow.pl
+%
+% ODRL policy rules, trust scores, and requested flows are RDF data. The rules
+% produce one deterministic FPV-style decision report.
+%% goal: trust_flow_report(_)
+
+trust_flow_report([Care, Clinic, Ads]) :-
+  flow_decision(flow_care, Care),
+  flow_decision(flow_clinic, Clinic),
+  flow_decision(flow_ads, Ads).
+
+flow_decision(Flow, decision(Flow, permit, confidence(Score), status(executable_flow))) :-
+  permitted_flow(Flow, Score).
+flow_decision(Flow, decision(Flow, review, confidence(Score), risk(trustworthiness_risk))) :-
+  review_flow(Flow, Score).
+flow_decision(Flow, decision(Flow, deny, status(blocked_flow), risk(unwanted_disclosure))) :-
+  prohibited_flow(Flow).
+
+permitted_flow(Flow, Score) :-
+  flow_request(Flow, Source, Recipient, Data, Action, Purpose),
+  policy_rule(odrl(permission), Rule, Recipient, Data, Action, Purpose),
+  rdf_number(Rule, ex(minTrust), Minimum),
+  rdf_number(Source, ex(trustScore), Score),
+  Score >= Minimum.
+
+review_flow(Flow, Score) :-
+  flow_request(Flow, Source, Recipient, Data, Action, Purpose),
+  policy_rule(odrl(permission), Rule, Recipient, Data, Action, Purpose),
+  rdf_number(Rule, ex(minTrust), Minimum),
+  rdf_number(Source, ex(trustScore), Score),
+  Score < Minimum.
+
+prohibited_flow(Flow) :-
+  flow_request(Flow, _Source, Recipient, Data, Action, Purpose),
+  policy_rule(odrl(prohibition), _Rule, Recipient, Data, Action, Purpose).
+
+flow_request(Flow, Source, Recipient, Data, Action, Purpose) :-
+  flow_resource(Flow, Resource),
+  rdf_link(Resource, ex(source), Source),
+  rdf_link(Resource, ex(recipient), Recipient),
+  rdf_link(Resource, ex(data), Data),
+  rdf_link(Resource, ex(requestedAction), Action),
+  rdf_link(Resource, ex(requestedPurpose), Purpose).
+
+policy_rule(Type, Rule, Recipient, Data, Action, Purpose) :-
+  rdf_link(ex('trust-policy'), Type, Rule),
+  rdf_link(Rule, odrl(assignee), Recipient),
+  rdf_link(Rule, odrl(target), Data),
+  rdf_link(Rule, odrl(action), Action),
+  rdf_link(Rule, odrl(purpose), Purpose).
+
+flow_resource(flow_care, ex('flow-care')).
+flow_resource(flow_clinic, ex('flow-clinic')).
+flow_resource(flow_ads, ex('flow-ads')).
+
+rdf_link(Subject, Predicate, Object) :-
+  iri_term(Subject, SubjectIri),
+  iri_term(Predicate, PredicateIri),
+  rdf(iri(SubjectIri), iri(PredicateIri), iri(ObjectIri), default_graph),
+  iri_term(Object, ObjectIri).
+
+rdf_number(Subject, Predicate, Number) :-
+  iri_term(Subject, SubjectIri),
+  iri_term(Predicate, PredicateIri),
+  rdf(iri(SubjectIri), iri(PredicateIri), literal(Text, datatype(_Datatype)), default_graph),
+  number_string(Number, Text).
+
+iri_term(ex(Name), Iri) :- namespace_iri("https://example.org/", Name, Iri).
+iri_term(odrl(Name), Iri) :- namespace_iri("http://www.w3.org/ns/odrl/2/", Name, Iri).
+
+namespace_iri(Prefix, Name, Iri) :-
+  atom(Name),
+  !,
+  atom_string(Name, Local),
+  string_concat(Prefix, Local, Iri).
+namespace_iri(Prefix, Name, Iri) :-
+  string_concat(Prefix, Local, Iri),
+  atom_string(Name, Local).

package/examples/input/odrl-dpv-fpv-trust-flow.ttl

@@ -0,0 +1,38 @@
+@prefix odrl: <http://www.w3.org/ns/odrl/2/> .
+@prefix ex: <https://example.org/> .
+
+ex:trust-policy odrl:permission ex:healthcare-permission .
+ex:trust-policy odrl:prohibition ex:marketing-prohibition .
+
+ex:healthcare-permission odrl:assignee ex:research-partner .
+ex:healthcare-permission odrl:target ex:lab-result .
+ex:healthcare-permission odrl:action odrl:use .
+ex:healthcare-permission odrl:purpose ex:healthcare .
+ex:healthcare-permission ex:minTrust "0.80" .
+
+ex:marketing-prohibition odrl:assignee ex:ad-network .
+ex:marketing-prohibition odrl:target ex:lab-result .
+ex:marketing-prohibition odrl:action odrl:distribute .
+ex:marketing-prohibition odrl:purpose ex:marketing .
+
+ex:hospital-a ex:trustScore "0.92" .
+ex:small-clinic ex:trustScore "0.63" .
+ex:ad-network ex:trustScore "0.28" .
+
+ex:flow-care ex:source ex:hospital-a .
+ex:flow-care ex:recipient ex:research-partner .
+ex:flow-care ex:data ex:lab-result .
+ex:flow-care ex:requestedAction odrl:use .
+ex:flow-care ex:requestedPurpose ex:healthcare .
+
+ex:flow-clinic ex:source ex:small-clinic .
+ex:flow-clinic ex:recipient ex:research-partner .
+ex:flow-clinic ex:data ex:lab-result .
+ex:flow-clinic ex:requestedAction odrl:use .
+ex:flow-clinic ex:requestedPurpose ex:healthcare .
+
+ex:flow-ads ex:source ex:hospital-a .
+ex:flow-ads ex:recipient ex:ad-network .
+ex:flow-ads ex:data ex:lab-result .
+ex:flow-ads ex:requestedAction odrl:distribute .
+ex:flow-ads ex:requestedPurpose ex:marketing .