seam-lang 2.0.0

package/examples/matrix-noncommutativity.pl

@@ -0,0 +1,43 @@
+% Matrix multiplication and non-commutativity.
+%
+% The original matrix example contains a larger matrix library.  This compact
+% Seam case keeps the core operation visible: multiply two 2x2 matrices and
+% show that, in general, A*B is not the same matrix as B*A.
+
+materialize(matrix_result, 2).
+
+matrix_a([[1, 2], [0, 1]]).
+matrix_b([[1, 0], [3, 1]]).
+
+dot2([X1, X2], [Y1, Y2], R) :-
+  mul(X1, Y1, P1),
+  mul(X2, Y2, P2),
+  add(P1, P2, R).
+
+transpose2([[A, B], [C, D]], [[A, C], [B, D]]).
+
+row_times_matrix(Row, Matrix, [R1, R2]) :-
+  transpose2(Matrix, [Col1, Col2]),
+  dot2(Row, Col1, R1),
+  dot2(Row, Col2, R2).
+
+matrix_mul([Row1, Row2], Matrix, [Out1, Out2]) :-
+  row_times_matrix(Row1, Matrix, Out1),
+  row_times_matrix(Row2, Matrix, Out2).
+
+matrix_result(ab, Ab) :-
+  matrix_a(A),
+  matrix_b(B),
+  matrix_mul(A, B, Ab).
+
+matrix_result(ba, Ba) :-
+  matrix_a(A),
+  matrix_b(B),
+  matrix_mul(B, A, Ba).
+
+matrix_result(commutative, false) :-
+  matrix_a(A),
+  matrix_b(B),
+  matrix_mul(A, B, Ab),
+  matrix_mul(B, A, Ba),
+  neq(Ab, Ba).

package/examples/microgrid-dispatch.pl

@@ -0,0 +1,89 @@
+% Representative example: microgrid dispatch planning.
+%
+% The rules compute renewable supply, reserve-aware battery dispatch, remaining
+% grid import, and a concise feasibility report for a campus microgrid interval.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+%
+% The dispatch policy is greedy but auditable: use renewables first, discharge
+% the battery only down to reserve, then import the remaining deficit from grid.
+materialize(renewablePower_kW, 2).
+materialize(batteryDispatch_kW, 2).
+materialize(gridImport_kW, 2).
+materialize(reserveAfterDispatch_kW, 2).
+materialize(status, 2).
+materialize(reason, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+site(campus_interval_17).
+
+load_kW(campus_interval_17, 620.0).
+solar_kW(campus_interval_17, 180.0).
+wind_kW(campus_interval_17, 90.0).
+battery_max_discharge_kW(campus_interval_17, 320.0).
+required_battery_reserve_kW(campus_interval_17, 80.0).
+grid_contract_limit_kW(campus_interval_17, 150.0).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+renewable_kW(Site, Renewable) :-
+  solar_kW(Site, Solar),
+  wind_kW(Site, Wind),
+  add(Solar, Wind, Renewable).
+
+net_deficit_kW(Site, Deficit) :-
+  load_kW(Site, Load),
+  renewable_kW(Site, Renewable),
+  sub(Load, Renewable, Deficit).
+
+reserve_aware_battery_limit_kW(Site, Limit) :-
+  battery_max_discharge_kW(Site, Maxdischarge),
+  required_battery_reserve_kW(Site, Reserve),
+  sub(Maxdischarge, Reserve, Limit).
+
+battery_dispatch_kW(Site, Dispatch) :-
+  net_deficit_kW(Site, Deficit),
+  reserve_aware_battery_limit_kW(Site, Limit),
+  min(Deficit, Limit, Dispatch).
+
+grid_import_kW(Site, Import) :-
+  net_deficit_kW(Site, Deficit),
+  battery_dispatch_kW(Site, Dispatch),
+  sub(Deficit, Dispatch, Import).
+
+battery_reserve_after_dispatch_kW(Site, Reserveleft) :-
+  battery_max_discharge_kW(Site, Maxdischarge),
+  battery_dispatch_kW(Site, Dispatch),
+  sub(Maxdischarge, Dispatch, Reserveleft).
+
+contract_ok(Site) :-
+  grid_import_kW(Site, Import),
+  grid_contract_limit_kW(Site, Limit),
+  le(Import, Limit).
+
+reserve_ok(Site) :-
+  battery_reserve_after_dispatch_kW(Site, Reserveleft),
+  required_battery_reserve_kW(Site, Required),
+  ge(Reserveleft, Required).
+
+% stable_dispatch/1 passes only when contract and reserve constraints remain satisfied.
+stable_dispatch(Site) :-
+  contract_ok(Site),
+  reserve_ok(Site).
+
+renewablePower_kW(Site, Renewable) :-
+  renewable_kW(Site, Renewable).
+
+batteryDispatch_kW(Site, Dispatch) :-
+  battery_dispatch_kW(Site, Dispatch).
+
+gridImport_kW(Site, Import) :-
+  grid_import_kW(Site, Import).
+
+reserveAfterDispatch_kW(Site, Reserveleft) :-
+  battery_reserve_after_dispatch_kW(Site, Reserveleft).
+
+status(Site, stable_dispatch) :-
+  stable_dispatch(Site).
+
+reason(Site, "battery dispatch covers the deficit while preserving reserve and grid contract limits") :-
+  stable_dispatch(Site).

package/examples/missionaries-cannibals.pl

@@ -0,0 +1,53 @@
+% Missionaries-and-cannibals river crossing as guarded state-space search.
+%
+% A state records missionaries and cannibals on the left bank plus the boat side.
+% crossing/3 applies one legal boat load and state_safe/1 checks both banks.
+% journey/4 carries a visited list to avoid loops in the finite state graph.
+materialize(missionaries_cannibals_answer, 2).
+
+% Boat loads: one or two passengers, with at least one passenger per crossing.
+move(1, 0).
+move(0, 1).
+move(2, 0).
+move(0, 2).
+move(1, 1).
+
+% A bank is safe if there are no missionaries or missionaries are not outnumbered.
+bank_safe(0, _c).
+bank_safe(M, C) :- gt(M, 0), ge(M, C).
+
+state_safe(state(Mleft, Cleft, _boat)) :-
+  between(0, 3, Mleft),
+  between(0, 3, Cleft),
+  sub(3, Mleft, Mright),
+  sub(3, Cleft, Cright),
+  bank_safe(Mleft, Cleft),
+  bank_safe(Mright, Cright).
+
+crossing(state(Mleft, Cleft, left), state(Nextm, Nextc, right), carry(Movem, Movec)) :-
+  move(Movem, Movec),
+  sub(Mleft, Movem, Nextm),
+  sub(Cleft, Movec, Nextc),
+  state_safe(state(Nextm, Nextc, right)).
+crossing(state(Mleft, Cleft, right), state(Nextm, Nextc, left), carry(Movem, Movec)) :-
+  move(Movem, Movec),
+  add(Mleft, Movem, Nextm),
+  add(Cleft, Movec, Nextc),
+  state_safe(state(Nextm, Nextc, left)).
+
+journey(Goal, Goal, Visited, Visited).
+journey(State, Goal, Visited, Path) :-
+  crossing(State, Next, _carry),
+  not_member(Next, Visited),
+  journey(Next, Goal, [Next|Visited], Path).
+
+solution(Path) :-
+  journey(state(3, 3, left), state(0, 0, right), [state(3, 3, left)], Reversepath),
+  reverse(Reversepath, Path).
+
+missionaries_cannibals_answer(first_solution, Path) :- once(solution(Path)).
+missionaries_cannibals_answer(state_count, Count) :- countall(state_safe(state(_m, _c, _boat)), Count).
+missionaries_cannibals_answer(step_count, Steps) :-
+  once(solution(Path)),
+  length(Path, States),
+  sub(States, 1, Steps).

package/examples/modal-logic-kripke.pl

@@ -0,0 +1,45 @@
+% Modal logic emulation with a finite Kripke frame.
+%
+% Worlds and accessibility edges are ordinary facts.  mforces/2 interprets modal
+% formula terms such as box(clear) and diamond(repaired).  box(F) is true at a
+% world when every accessible world satisfies F; diamond(F) is true when at
+% least one accessible world satisfies F.
+materialize(modal_truth, 3).
+materialize(modal_countermodel, 2).
+
+world(w0).
+world(w1).
+world(w2).
+world(w3).
+
+accessible(w0, w1).
+accessible(w0, w2).
+accessible(w1, w1).
+accessible(w1, w3).
+accessible(w2, w2).
+accessible(w3, w3).
+
+true_at(w1, clear).
+true_at(w2, clear).
+true_at(w3, clear).
+true_at(w2, repaired).
+
+mforces(_world, top).
+mforces(World, atom(Prop)) :- true_at(World, Prop).
+mforces(World, and(Left, Right)) :- mforces(World, Left), mforces(World, Right).
+mforces(World, diamond(Formula)) :- accessible(World, Next), mforces(Next, Formula).
+mforces(World, box(Formula)) :-
+  world(World),
+  forall(accessible(World, Next), mforces(Next, Formula)).
+
+modal_truth(all_accessible_worlds_clear, w0, box(atom(clear))) :-
+  mforces(w0, box(atom(clear))).
+
+modal_truth(repair_is_possible, w0, diamond(atom(repaired))) :-
+  mforces(w0, diamond(atom(repaired))).
+
+modal_truth(nested_possibility, w1, diamond(and(atom(clear), atom(clear)))) :-
+  mforces(w1, diamond(and(atom(clear), atom(clear)))).
+
+modal_countermodel(repair_not_necessary, w0) :-
+  not(mforces(w0, box(atom(repaired)))).

package/examples/modular-exponentiation.pl

@@ -0,0 +1,35 @@
+% Modular exponentiation by repeated squaring.
+%
+% pow_mod(Base, Exp, Modulus, Result) uses the even/odd exponent split, giving
+% logarithmic-depth arithmetic.  Memoization matters when the same modular powers
+% are reused by Fermat-style congruence checks.
+materialize(modular_answer, 2).
+
+table(pow_mod, 4).
+
+% Base case: any nonzero base to exponent zero is 1 modulo Mod.
+pow_mod(_base, 0, Mod, Result) :- mod(1, Mod, Result).
+pow_mod(Base, Exp, Modulus, Result) :-
+  gt(Exp, 0),
+  mod(Exp, 2, 0),
+  div(Exp, 2, Half),
+  pow_mod(Base, Half, Modulus, Halfpower),
+  mul(Halfpower, Halfpower, Square),
+  mod(Square, Modulus, Result).
+pow_mod(Base, Exp, Modulus, Result) :-
+  gt(Exp, 0),
+  mod(Exp, 2, 1),
+  sub(Exp, 1, Evenexp),
+  pow_mod(Base, Evenexp, Modulus, Evenpower),
+  mul(Base, Evenpower, Product),
+  mod(Product, Modulus, Result).
+
+% This is a Fermat congruence check, not a full primality proof.
+fermat_witness(Base, Primecandidate) :-
+  sub(Primecandidate, 1, Exponent),
+  pow_mod(Base, Exponent, Primecandidate, 1).
+
+modular_answer(pow_7_560_mod_561, R) :- pow_mod(7, 560, 561, R).
+modular_answer(pow_2_1000_mod_1009, R) :- pow_mod(2, 1000, 1009, R).
+modular_answer(fermat_2_101, true) :- fermat_witness(2, 101).
+modular_answer(fermat_3_101, true) :- fermat_witness(3, 101).

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.
+table(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/n-queens-8.pl

@@ -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.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,48 @@
+% Newton-Raphson root finding, adapted from Eyelet input/newton-raphson.pl.
+% 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.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,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.pl

@@ -0,0 +1,51 @@
+% ODRL + DPV + local FPV trust-flow decisioning in Seam.
+%
+% 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).