eyelang 0.1.0

package/examples/monkey-bananas.pl

@@ -0,0 +1,45 @@
+% Monkey and bananas planning problem, adapted from Eyelet's
+% input/monkey-bananas.pl.
+%
+% A state is [bananas_location, monkey_location, box_location, on_box,
+% has_bananas].  The selected output searches bounded move lists and derives successful
+% plans.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(plan, 2).
+materialize(solved, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+memoize(reachable, 3).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+plan(Moves) :-
+  candidate_plan(Moves),
+  initial_state(I),
+  goal_state(G),
+  reachable(I, Moves, G).
+
+candidate_plan([_, _, _]).
+candidate_plan([_, _, _, _]).
+candidate_plan([_, _, _, _, _]).
+
+reachable(S, [], S).
+reachable(S1, [M|L], S3) :-
+  legal_move(S1, M, S2),
+  reachable(S2, L, S3).
+
+initial_state([loc1, loc2, loc3, n, n]).
+goal_state([_, _, _, _, y]).
+
+legal_move([B, M, M, n, H], climb_on, [B, M, M, y, H]).
+legal_move([B, M, M, y, H], climb_off, [B, M, M, n, H]).
+legal_move([B, B, B, y, n], grab, [B, B, B, y, y]).
+legal_move([B, M, M, n, H], push(X), [B, X, X, n, H]) :-
+  member(X, [loc1, loc2, loc3]),
+  neq(X, M).
+legal_move([B, M, L, n, H], go(X), [B, X, L, n, H]) :-
+  member(X, [loc1, loc2, loc3]),
+  neq(X, M).
+
+plan(monkeyBananas, Moves) :- plan(Moves).
+solved(monkeyBananas, true) :- plan(_Moves).

package/examples/network-sla.pl

@@ -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.pl

@@ -0,0 +1,49 @@
+% Newton-Raphson root finding, adapted from Eyelet input/newton-raphson.pl.
+% The selected roots match Eyelet output-swipl/newton-raphson.pl.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(findRoot, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+want_root([1, 1.0, 1.0e-15]).
+want_root([2, 2.0, 1.0e-15]).
+want_root([3, 3.0, 1.0e-15]).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+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.pl

@@ -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.pl

@@ -0,0 +1,34 @@
+% Parse unstructured service logs with named regex captures, then reason over
+% the extracted context to correlate events that share a trace id.
+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).
+
+% holds/3 lets one generic rule project every named capture as field data.
+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.pl

@@ -0,0 +1,43 @@
+% ODRL + DPV + local FPV trust-flow decisioning in eyelang.
+
+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.pl

@@ -0,0 +1,266 @@
+% ODRL + DPV healthcare risk ranking adapted from Eyeling
+% odrl-dpv-healthcare-risk-ranked.n3.
+% The agreement policy and mitigation suggestions are formula-valued terms.
+
+% 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).