eyelang 1.2.2 → 1.3.1

package/examples/n-queens-8.eye

@@ -0,0 +1,35 @@
+% N-queens search for the 8x8 board.
+%
+% A solution is represented as a list of row numbers, one per column.  Using a
+% permutation enforces one queen per row automatically; safe_rows/1 only has to
+% reject diagonal attacks.
+materialize(n_queens_answer, 2).
+
+% Cache diagonal checks; the same row/distance/suffix states recur across many
+% candidate permutations during the 8-queens search.  The example asks only for
+% the first solution with once/1, keeping it playground-friendly.
+table(no_diagonal_attack, 3).
+
+perm([], []).
+perm(?items, [?x|?rest]) :-
+  select(?x, ?items, ?remaining),
+  perm(?remaining, ?rest).
+
+safe_rows([]).
+safe_rows([?row|?rest]) :-
+  no_diagonal_attack(?row, 1, ?rest),
+  safe_rows(?rest).
+
+no_diagonal_attack(?_row, ?_distance, []).
+no_diagonal_attack(?row, ?distance, [?other|?rest]) :-
+  sub(?row, ?other, ?delta),
+  abs(?delta, ?absdelta),
+  neq(?absdelta, ?distance),
+  add(?distance, 1, ?nextdistance),
+  no_diagonal_attack(?row, ?nextdistance, ?rest).
+
+queen_solution(?rows) :-
+  perm([1, 2, 3, 4, 5, 6, 7, 8], ?rows),
+  safe_rows(?rows).
+
+n_queens_answer(first_solution, ?rows) :- once(queen_solution(?rows)).

package/examples/network-sla.eye

@@ -0,0 +1,48 @@
+% Technology example: network path SLA check.
+%
+% The path latency is the sum of link delays plus jitter. The path is compliant
+% when the resulting end-to-end latency stays below the SLA limit.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(endToEndLatency_ms, 2).
+materialize(slaLimit_ms, 2).
+materialize(status, 2).
+materialize(reason, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+path(edge_path, [link_a, link_b, link_c]).
+link_latency(link_a, 12.0).
+link_latency(link_b, 18.0).
+link_latency(link_c, 9.0).
+jitter(edge_path, 8.0).
+sla(edge_path, maximum_latency_ms, 50.0).
+
+latency_sum([], 0.0).
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+latency_sum([?link|?links], ?total) :-
+  link_latency(?link, ?linklatency),
+  latency_sum(?links, ?rest),
+  add(?linklatency, ?rest, ?total).
+
+end_to_end_latency(?path, ?latency) :-
+  path(?path, ?links),
+  latency_sum(?links, ?linklatency),
+  jitter(?path, ?jitter),
+  add(?linklatency, ?jitter, ?latency).
+
+sla_compliant(?path) :-
+  end_to_end_latency(?path, ?latency),
+  sla(?path, maximum_latency_ms, ?maximum),
+  lt(?latency, ?maximum).
+
+endToEndLatency_ms(?path, ?latency) :-
+  end_to_end_latency(?path, ?latency).
+
+slaLimit_ms(?path, ?maximum) :-
+  sla(?path, maximum_latency_ms, ?maximum).
+
+status(?path, sla_compliant) :-
+  sla_compliant(?path).
+
+reason(?path, "path latency including jitter is below the SLA limit") :-
+  sla_compliant(?path).

package/examples/newton-raphson.eye

@@ -0,0 +1,48 @@
+% Newton-Raphson root finding, adapted from Eyelet input/newton-raphson.eye.
+% Each want_root/1 case names a function, starting point, and tolerance.  The
+% recursive finder stops when |f(x)| is below tolerance; otherwise it applies
+% x := x - f(x)/f'(x) using the corresponding derivative rule.
+
+materialize(findRoot, 2).
+
+want_root([1, 1.0, 1.0e-15]).
+want_root([2, 2.0, 1.0e-15]).
+want_root([3, 3.0, 1.0e-15]).
+
+findRoot(?input, ?root) :-
+  want_root(?input),
+  find_root(?input, ?root).
+
+% f(1, X) = X^2 - 2
+f(1, ?x, ?y) :-
+  mul(?x, ?x, ?xx),
+  sub(?xx, 2, ?y).
+
+% f(2, X) = log(X) - 1
+f(2, ?x, ?y) :-
+  log(?x, ?lx),
+  sub(?lx, 1, ?y).
+
+% f(3, X) = sin(X)
+f(3, ?x, ?y) :-
+  sin(?x, ?y).
+
+fd(1, ?x, ?y) :-
+  mul(2, ?x, ?y).
+fd(2, ?x, ?y) :-
+  div(1, ?x, ?y).
+fd(3, ?x, ?y) :-
+  cos(?x, ?y).
+
+find_root([?n, ?x, ?tolerance], ?x) :-
+  f(?n, ?x, ?fx),
+  abs(?fx, ?afx),
+  lt(?afx, ?tolerance).
+find_root([?n, ?x, ?tolerance], ?root) :-
+  f(?n, ?x, ?fx),
+  abs(?fx, ?afx),
+  ge(?afx, ?tolerance),
+  fd(?n, ?x, ?fdx),
+  div(?fx, ?fdx, ?step),
+  sub(?x, ?step, ?newx),
+  find_root([?n, ?newx, ?tolerance], ?root).

package/examples/nixon-diamond.eye

@@ -0,0 +1,37 @@
+% Nixon diamond: two independent defaults support incompatible conclusions.
+% This mirrors the classic EYE reasoning theme while keeping the conclusion explicit:
+% a subject with both defaults is reported as conflicted rather than forced to
+% choose one extension.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(defaultSupports, 2).
+materialize(conflict, 2).
+materialize(status, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+kind(nixon, quaker).
+kind(nixon, republican).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+supports_default(?person, pacifist) :-
+  kind(?person, quaker).
+
+supports_default(?person, hawk) :-
+  kind(?person, republican).
+
+contrary(pacifist, hawk).
+contrary(hawk, pacifist).
+
+conflicted(?person, ?a, ?b) :-
+  supports_default(?person, ?a),
+  supports_default(?person, ?b),
+  contrary(?a, ?b).
+
+defaultSupports(?person, ?conclusion) :-
+  supports_default(?person, ?conclusion).
+
+conflict(?person, conflict(?a, ?b)) :-
+  conflicted(?person, ?a, ?b).
+
+status(?person, conflicted_default_case) :-
+  conflicted(?person, ?_a, ?_b).

package/examples/observability-log-correlation.eye

@@ -0,0 +1,40 @@
+% Observability example: parse unstructured service logs with named regex
+% captures, then reason over the extracted context to correlate events that
+% share a W3C trace id.
+%
+% The noisy health-check line is deliberately present to show that only logs
+% matching the pattern become parsed events.
+materialize(parsed_event, 5).
+materialize(captured_field, 3).
+materialize(trace_alert, 3).
+
+log_pattern("^ts=(?<ts>\\S+) level=(?<level>\\w+) event=(?<event>\\w+) user=(?<user>\\w+) ip=(?<ip>\\S+) traceparent=00-(?<trace_id>[0-9a-f]{32})-(?<span_id>[0-9a-f]{16})-(?<flags>[0-9a-f]{2})$").
+
+raw_log(l1, "ts=2026-06-18T10:00:00Z level=warn event=login_failed user=alice ip=203.0.113.9 traceparent=00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01").
+raw_log(l2, "ts=2026-06-18T10:00:03Z level=error event=payment_denied user=alice ip=203.0.113.9 traceparent=00-4bf92f3577b34da6a3ce929d0e0e4736-aaf067aa0ba90000-01").
+raw_log(l3, "ts=2026-06-18T10:01:12Z level=info event=login_success user=bob ip=198.51.100.4 traceparent=00-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa-bbbbbbbbbbbbbbbb-01").
+raw_log(noise, "healthcheck ok").
+
+parsed(?log, ?context) :-
+  raw_log(?log, ?text),
+  log_pattern(?pattern),
+  matches(?text, ?pattern, ?context).
+
+% matches/3 returns a context term containing named captures.  holds/3 then
+% projects either Name, Value pairs or field(Value) shorthand facts from that
+% same context without writing one regex per field.
+captured_field(?log, ?name, ?value) :-
+  parsed(?log, ?context),
+  holds(?context, ?name, [?value]).
+
+parsed_event(?log, ?event, ?user, ?ip, ?traceid) :-
+  parsed(?log, ?context),
+  holds(?context, event(?event)),
+  holds(?context, user(?user)),
+  holds(?context, ip(?ip)),
+  holds(?context, trace_id(?traceid)).
+
+trace_alert(?user, ?traceid, ?ip) :-
+  parsed_event(?loginlog, "login_failed", ?user, ?ip, ?traceid),
+  parsed_event(?paymentlog, "payment_denied", ?user, ?ip, ?traceid),
+  neq(?loginlog, ?paymentlog).

package/examples/odrl-dpv-fpv-trust-flow.eye

@@ -0,0 +1,51 @@
+% ODRL + DPV + local FPV trust-flow decisioning in Eyelang.
+%
+% Each flow has a source, recipient, data item, action, and purpose.  Permissions
+% and prohibitions are checked together with source trust scores to produce
+% permit, review, or deny decisions.
+%
+% The example separates the policy vocabulary from the local FPV-style report
+% predicates, which keeps the final decision/confidence/status/risk facts easy to
+% consume.
+
+materialize(decision, 2).
+materialize(confidence, 2).
+materialize(status, 2).
+materialize(risk, 2).
+
+trust_score(hospital_a, 0.92).
+trust_score(small_clinic, 0.63).
+trust_score(ad_network, 0.28).
+
+flow(flow_care, hospital_a, research_partner, lab_result, dpv_use, dpv_healthcare).
+flow(flow_clinic, small_clinic, research_partner, lab_result, dpv_use, dpv_healthcare).
+flow(flow_ads, hospital_a, ad_network, lab_result, dpv_share, dpv_marketing).
+
+permission(permit_healthcare_research, research_partner, lab_result, dpv_use, dpv_healthcare, 0.80).
+prohibition(prohibit_marketing_disclosure, ad_network, lab_result, dpv_share, dpv_marketing).
+
+permitted_flow(?flow, ?score) :-
+  flow(?flow, ?source, ?recipient, ?data, ?action, ?purpose),
+  permission(?_permission, ?recipient, ?data, ?action, ?purpose, ?mintrust),
+  trust_score(?source, ?score),
+  ge(?score, ?mintrust).
+
+review_flow(?flow, ?score) :-
+  flow(?flow, ?source, ?recipient, ?data, ?action, ?purpose),
+  permission(?_permission, ?recipient, ?data, ?action, ?purpose, ?mintrust),
+  trust_score(?source, ?score),
+  lt(?score, ?mintrust).
+
+denied_flow(?flow) :-
+  flow(?flow, ?_source, ?recipient, ?data, ?action, ?purpose),
+  prohibition(?_prohibition, ?recipient, ?data, ?action, ?purpose).
+
+decision(?flow, fpv_permit) :- permitted_flow(?flow, ?_score).
+decision(?flow, fpv_review) :- review_flow(?flow, ?_score).
+decision(?flow, fpv_deny) :- denied_flow(?flow).
+confidence(?flow, ?score) :- permitted_flow(?flow, ?score).
+confidence(?flow, ?score) :- review_flow(?flow, ?score).
+status(?flow, fpv_executable_flow) :- permitted_flow(?flow, ?_score).
+status(?flow, fpv_blocked_flow) :- denied_flow(?flow).
+risk(?flow, risk_trustworthiness_risk) :- review_flow(?flow, ?_score).
+risk(?flow, risk_unwanted_disclosure_data) :- denied_flow(?flow).

package/examples/odrl-dpv-healthcare-risk-ranked.eye

@@ -0,0 +1,270 @@
+% ODRL + DPV healthcare risk ranking adapted from Eyeling.
+%
+% The scenario models a healthcare data-use agreement, patient needs, processing
+% clauses, risk scores, and mitigation suggestions.  Rules derive violations, raw
+% and normalized scores, risk levels, and small formula-valued suggestion graphs.
+%
+% This is one of the richer policy examples: it combines structured policy data,
+% ranked risk computation, and report-oriented materialization.
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(policyGraph, 2).
+materialize(contains, 2).
+materialize(dpv_hasRisk, 2).
+materialize(type, 2).
+materialize(scoreRaw, 2).
+materialize(score, 2).
+materialize(dpv_hasRiskLevel, 2).
+materialize(dpv_hasSeverity, 2).
+materialize(aboutClause, 2).
+materialize(violatesNeed, 2).
+materialize(dct_source, 2).
+materialize(dct_description, 2).
+materialize(reportKey, 2).
+materialize(dpv_isMitigatedByMeasure, 2).
+materialize(suggestAddGraph, 2).
+materialize(firstRisk, 2).
+materialize(retentionRiskScore, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+party(hospital).
+party(researchUnit).
+party(pharmaPartner).
+party(clinicalAIService).
+data_asset(healthRecordData).
+data_asset(genomicData).
+process(processContextHC1).
+
+title(agreementHC1, "Example Healthcare & Life-Sciences Data Use Agreement").
+title(patientExample, "Example patient profile").
+
+has_need(patientExample, need_ConsentForResearch).
+has_need(patientExample, need_DeIdentifyBeforeSharing).
+has_need(patientExample, need_HumanReviewForAutomatedTriage).
+has_need(patientExample, need_RetentionLimit3y).
+
+importance(need_ConsentForResearch, 35).
+importance(need_DeIdentifyBeforeSharing, 35).
+importance(need_HumanReviewForAutomatedTriage, 25).
+importance(need_RetentionLimit3y, 15).
+max_retention_days(need_RetentionLimit3y, 1095).
+
+clause_id(clauseH1, "H1").
+clause_text(clauseH1, "Hospital may use EHR and genomic data for internal clinical research and publication.").
+clause_id(clauseH2, "H2").
+clause_text(clauseH2, "Hospital may share genomic data with pharmaceutical partners for drug discovery and R&D.").
+clause_id(clauseH3, "H3").
+clause_text(clauseH3, "Hospital may use automated triage and prioritisation systems using EHR data.").
+clause_id(clauseH4, "H4").
+clause_text(clauseH4, "Hospital retains patient health records for 10 years.").
+
+agreement_policy_graph(agreementHC1, policyGraphHC1).
+
+policy_graph(policyGraphHC1, (
+  type(policyHC1, odrl_Policy),
+  odrl_permission(policyHC1, permResearchUse),
+  odrl_permission(policyHC1, permShareWithPharma),
+  odrl_permission(policyHC1, permAutomatedTriage),
+  odrl_permission(policyHC1, permRetention10y),
+
+  type(permResearchUse, odrl_Permission),
+  odrl_assigner(permResearchUse, hospital),
+  odrl_assignee(permResearchUse, researchUnit),
+  odrl_action(permResearchUse, hl7ca_use),
+  odrl_target(permResearchUse, healthRecordData),
+  odrl_target(permResearchUse, genomicData),
+  odrl_constraint(permResearchUse, cResearchPurpose),
+  odrl_leftOperand(cResearchPurpose, odrl_purpose),
+  odrl_rightOperandReference(cResearchPurpose, purposeHMB),
+  clause(permResearchUse, clauseH1),
+
+  type(permShareWithPharma, odrl_Permission),
+  odrl_assigner(permShareWithPharma, hospital),
+  odrl_assignee(permShareWithPharma, pharmaPartner),
+  odrl_action(permShareWithPharma, hl7ca_disclose),
+  odrl_target(permShareWithPharma, genomicData),
+  odrl_constraint(permShareWithPharma, cSharePurpose),
+  odrl_leftOperand(cSharePurpose, odrl_purpose),
+  odrl_rightOperandReference(cSharePurpose, purposeHMB),
+  clause(permShareWithPharma, clauseH2),
+
+  type(permAutomatedTriage, odrl_Permission),
+  odrl_assigner(permAutomatedTriage, hospital),
+  odrl_assignee(permAutomatedTriage, clinicalAIService),
+  odrl_action(permAutomatedTriage, hl7ca_use),
+  odrl_target(permAutomatedTriage, healthRecordData),
+  odrl_constraint(permAutomatedTriage, cTriagePurpose),
+  odrl_leftOperand(cTriagePurpose, odrl_purpose),
+  odrl_rightOperandReference(cTriagePurpose, purposeCC),
+  odrl_duty(permAutomatedTriage, dutyHumanReview),
+  odrl_action(dutyHumanReview, humanReview),
+  odrl_constraint(dutyHumanReview, cTriageEncryption),
+  odrl_leftOperand(cTriageEncryption, encryptionAtRest),
+  odrl_rightOperand(cTriageEncryption, true),
+  clause(permAutomatedTriage, clauseH3),
+
+  type(permRetention10y, odrl_Permission),
+  odrl_assigner(permRetention10y, hospital),
+  odrl_assignee(permRetention10y, hospital),
+  odrl_action(permRetention10y, hl7ca_collect),
+  odrl_target(permRetention10y, healthRecordData),
+  odrl_constraint(permRetention10y, cRetentionPurpose),
+  odrl_leftOperand(cRetentionPurpose, odrl_purpose),
+  odrl_rightOperandReference(cRetentionPurpose, purposeCC),
+  odrl_constraint(permRetention10y, cRetentionDays),
+  odrl_leftOperand(cRetentionDays, retentionDays),
+  odrl_rightOperand(cRetentionDays, 3650),
+  clause(permRetention10y, clauseH4)
+)).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+policy_statement(?graphname, ?subject, ?predicate, ?object) :-
+  policy_graph(?graphname, ?context),
+  holds(?context, ?predicate, [?subject, ?object]).
+
+permission(?graph, ?permission) :- policy_statement(?graph, policyHC1, odrl_permission, ?permission).
+clause(?graph, ?permission, ?clause) :- policy_statement(?graph, ?permission, clause, ?clause).
+action(?graph, ?permission, ?action) :- policy_statement(?graph, ?permission, odrl_action, ?action).
+target(?graph, ?permission, ?target) :- policy_statement(?graph, ?permission, odrl_target, ?target).
+duty(?graph, ?permission, ?duty) :- policy_statement(?graph, ?permission, odrl_duty, ?duty).
+duty_action(?graph, ?duty, ?action) :- policy_statement(?graph, ?duty, odrl_action, ?action).
+constraint(?graph, ?permission, ?constraint) :- policy_statement(?graph, ?permission, odrl_constraint, ?constraint).
+constraint_left(?graph, ?constraint, ?left) :- policy_statement(?graph, ?constraint, odrl_leftOperand, ?left).
+constraint_right(?graph, ?constraint, ?right) :- policy_statement(?graph, ?constraint, odrl_rightOperand, ?right).
+
+has_constraint(?graph, ?permission, ?left, ?right) :-
+  constraint(?graph, ?permission, ?constraint),
+  constraint_left(?graph, ?constraint, ?left),
+  constraint_right(?graph, ?constraint, ?right).
+
+has_duty_action(?graph, ?permission, ?action) :-
+  duty(?graph, ?permission, ?duty),
+  duty_action(?graph, ?duty, ?action).
+
+missing_explicit_consent(?graph, ?permission) :-
+  permission(?graph, ?permission),
+  not(has_constraint(?graph, ?permission, explicitConsent, true)).
+
+missing_deidentified(?graph, ?permission) :-
+  permission(?graph, ?permission),
+  not(has_constraint(?graph, ?permission, deIdentified, true)).
+
+missing_human_review(?graph, ?permission) :-
+  permission(?graph, ?permission),
+  not(has_duty_action(?graph, ?permission, humanReview)).
+
+retention_days(?graph, ?permission, ?days) :-
+  has_constraint(?graph, ?permission, retentionDays, ?days).
+
+risk(riskH1) :-
+  agreement_policy_graph(agreementHC1, ?graph),
+  has_need(patientExample, need_ConsentForResearch),
+  permission(?graph, permResearchUse),
+  clause(?graph, permResearchUse, clauseH1),
+  missing_explicit_consent(?graph, permResearchUse).
+
+risk(riskH2) :-
+  agreement_policy_graph(agreementHC1, ?graph),
+  has_need(patientExample, need_DeIdentifyBeforeSharing),
+  permission(?graph, permShareWithPharma),
+  target(?graph, permShareWithPharma, genomicData),
+  clause(?graph, permShareWithPharma, clauseH2),
+  missing_deidentified(?graph, permShareWithPharma).
+
+risk(riskH3) :-
+  agreement_policy_graph(agreementHC1, ?graph),
+  has_need(patientExample, need_HumanReviewForAutomatedTriage),
+  permission(?graph, permAutomatedTriage),
+  clause(?graph, permAutomatedTriage, clauseH3),
+  missing_human_review(?graph, permAutomatedTriage).
+
+risk(riskH4) :-
+  agreement_policy_graph(agreementHC1, ?graph),
+  has_need(patientExample, need_RetentionLimit3y),
+  max_retention_days(need_RetentionLimit3y, ?max),
+  permission(?graph, permRetention10y),
+  clause(?graph, permRetention10y, clauseH4),
+  retention_days(?graph, permRetention10y, ?days),
+  gt(?days, ?max).
+
+base_score(riskH1, 85).
+base_score(riskH2, 90).
+base_score(riskH3, 80).
+base_score(riskH4, 55).
+violates_need(riskH1, need_ConsentForResearch).
+violates_need(riskH2, need_DeIdentifyBeforeSharing).
+violates_need(riskH3, need_HumanReviewForAutomatedTriage).
+violates_need(riskH4, need_RetentionLimit3y).
+about_clause(riskH1, clauseH1).
+about_clause(riskH2, clauseH2).
+about_clause(riskH3, clauseH3).
+about_clause(riskH4, clauseH4).
+risk_source_of(riskH1, permResearchUse).
+risk_source_of(riskH2, permShareWithPharma).
+risk_source_of(riskH3, permAutomatedTriage).
+risk_source_of(riskH4, permRetention10y).
+
+description(riskH1, "Risk: health/genomic data may be used for research without explicit opt-in consent.").
+description(riskH2, "Risk: genomic data may be shared with external pharma partners without a de-identification/pseudonymisation requirement.").
+description(riskH3, "Risk: automated triage may affect care pathways without a human review/override safeguard.").
+description(riskH4, "Risk: retention (3650 days) exceeds patient preference (1095 days).").
+
+mitigation_graph(riskH1, mitigateConsent, (
+  odrl_constraint(permResearchUse, cExplicitConsent),
+  odrl_leftOperand(cExplicitConsent, explicitConsent),
+  odrl_rightOperand(cExplicitConsent, true)
+)).
+mitigation_graph(riskH2, mitigateDeId, (
+  odrl_constraint(permShareWithPharma, cDeIdentified),
+  odrl_leftOperand(cDeIdentified, deIdentified),
+  odrl_rightOperand(cDeIdentified, true),
+  odrl_duty(permShareWithPharma, dutyDeIdentify),
+  odrl_action(dutyDeIdentify, deIdentify)
+)).
+mitigation_graph(riskH3, mitigateHumanReview, (
+  odrl_duty(permAutomatedTriage, dutyHumanReview),
+  odrl_action(dutyHumanReview, humanReview)
+)).
+mitigation_graph(riskH4, mitigateRetention, (
+  odrl_constraint(permRetention10y, cRetentionLimit),
+  odrl_leftOperand(cRetentionLimit, retentionDays),
+  odrl_rightOperand(cRetentionLimit, 1095)
+)).
+
+score_raw(?risk, ?raw) :-
+  risk(?risk),
+  base_score(?risk, ?base),
+  violates_need(?risk, ?need),
+  importance(?need, ?weight),
+  add(?base, ?weight, ?raw).
+
+score(?risk, 100) :- score_raw(?risk, ?raw), gt(?raw, 100).
+score(?risk, ?raw) :- score_raw(?risk, ?raw), ge(100, ?raw).
+
+severity(?risk, risk_HighSeverity) :- score(?risk, ?score), gt(?score, 79).
+severity(?risk, risk_ModerateSeverity) :- score(?risk, ?score), lt(?score, 80), gt(?score, 49).
+risk_level(?risk, risk_HighRisk) :- score(?risk, ?score), gt(?score, 79).
+risk_level(?risk, risk_ModerateRisk) :- score(?risk, ?score), lt(?score, 80), gt(?score, 49).
+
+report_key(?risk, ?key) :- score(?risk, ?score), sub(1000, ?score, ?key).
+
+policyGraph(agreementHC1, ?graphterm) :-
+  agreement_policy_graph(agreementHC1, ?graph),
+  policy_graph(?graph, ?graphterm).
+
+contains(policyGraphHC1, statement(?subject, ?predicate, ?object)) :-
+  policy_statement(policyGraphHC1, ?subject, ?predicate, ?object).
+
+dpv_hasRisk(processContextHC1, ?risk) :- risk(?risk).
+type(?risk, dpv_Risk) :- risk(?risk).
+scoreRaw(?risk, ?raw) :- score_raw(?risk, ?raw).
+dpv_hasRiskLevel(?risk, ?level) :- risk_level(?risk, ?level).
+dpv_hasSeverity(?risk, ?severity) :- severity(?risk, ?severity).
+aboutClause(?risk, ?clause) :- risk(?risk), about_clause(?risk, ?clause).
+violatesNeed(?risk, ?need) :- risk(?risk), violates_need(?risk, ?need).
+dct_source(?risk, ?source) :- risk(?risk), risk_source_of(?risk, ?source).
+dct_description(?risk, ?description) :- risk(?risk), description(?risk, ?description).
+reportKey(?risk, ?key) :- report_key(?risk, ?key).
+dpv_isMitigatedByMeasure(?risk, ?mitigation) :- risk(?risk), mitigation_graph(?risk, ?mitigation, ?_graph).
+suggestAddGraph(?mitigation, ?graph) :- mitigation_graph(?risk, ?mitigation, ?graph), risk(?risk).
+firstRisk(report, riskH1) :- score(riskH1, 100), score(riskH2, 100).
+retentionRiskScore(report, ?score) :- score(riskH4, ?score).