eyeling 1.32.0 → 1.33.0

package/examples/eyelang/gd-step-certified.pl

@@ -0,0 +1,158 @@
+% Memoize interval computations reused across width, midpoint, gradient, step,
+% objective, and contraction report relations.
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(eta, 2).
+materialize(etaLeHalf, 2).
+materialize(xBounds, 2).
+materialize(midpoint, 2).
+materialize(width, 2).
+materialize(gradientBounds, 2).
+materialize(stepBounds, 2).
+materialize(objectiveBounds, 2).
+materialize(widthContractsAt, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+memoize(x_bounds, 3).
+memoize(width, 2).
+memoize(g_bounds, 3).
+memoize(p_bounds, 3).
+memoize(midpoint, 3).
+memoize(f_lower, 2).
+memoize(f_upper, 2).
+
+% Adapted from Eyeling's gd-step-certified.n3.
+% One-dimensional gradient descent over certified interval bounds.
+
+max_k(10).
+target(1.0).
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+eta(Eta) :- div(1.0, 5, Eta).
+x_bounds(0, 0.0, 2.0).
+
+index(0). index(1). index(2). index(3). index(4). index(5).
+index(6). index(7). index(8). index(9). index(10).
+
+previous(1, 0). previous(2, 1). previous(3, 2). previous(4, 3). previous(5, 4).
+previous(6, 5). previous(7, 6). previous(8, 7). previous(9, 8). previous(10, 9).
+
+g_bounds(K, GL, GU) :-
+  target(A),
+  x_bounds(K, L, U),
+  sub(L, A, DL),
+  sub(U, A, DU),
+  mul(2, DL, GL),
+  mul(2, DU, GU).
+
+p_bounds(K, PL, PU) :-
+  eta(Eta),
+  g_bounds(K, GL, GU),
+  mul(Eta, GL, PL),
+  mul(Eta, GU, PU).
+
+x_bounds(K1, L1, U1) :-
+  previous(K1, K),
+  x_bounds(K, L, U),
+  target(A),
+  eta(Eta),
+  sub(L, A, DL),
+  sub(U, A, DU),
+  mul(2, DL, GL),
+  mul(2, DU, GU),
+  mul(Eta, GL, PL),
+  mul(Eta, GU, PU),
+  sub(L, PU, L1),
+  sub(U, PL, U1).
+
+width(K, W) :-
+  x_bounds(K, L, U),
+  sub(U, L, W).
+
+midpoint(K, M, HalfW) :-
+  x_bounds(K, L, U),
+  width(K, W),
+  div(W, 2, HalfW),
+  add(L, U, Sum),
+  div(Sum, 2, M).
+
+eta_le_half(true) :-
+  eta(Eta),
+  div(1.0, 2, Half),
+  le(Eta, Half).
+
+width_contracts_at(K1, true) :-
+  eta_le_half(true),
+  previous(K1, K),
+  width(K, W),
+  width(K1, W1),
+  le(W1, W).
+
+max2(A, B, A) :- ge(A, B).
+max2(A, B, B) :- lt(A, B).
+min2(A, B, A) :- le(A, B).
+min2(A, B, B) :- gt(A, B).
+
+end_squares(K, SL, SU) :-
+  target(A),
+  x_bounds(K, L, U),
+  sub(L, A, DL),
+  sub(U, A, DU),
+  mul(DL, DL, SL),
+  mul(DU, DU, SU).
+
+f_upper(K, FU) :-
+  end_squares(K, SL, SU),
+  max2(SL, SU, FU).
+
+f_lower(K, 0.0) :-
+  target(A),
+  x_bounds(K, L, U),
+  le(L, A),
+  le(A, U).
+
+f_lower(K, FL) :-
+  target(A),
+  x_bounds(K, L, U),
+  lt(U, A),
+  end_squares(K, SL, SU),
+  min2(SL, SU, FL).
+
+f_lower(K, FL) :-
+  target(A),
+  x_bounds(K, L, U),
+  lt(A, L),
+  end_squares(K, SL, SU),
+  min2(SL, SU, FL).
+
+eta(result, Eta) :-
+  eta(Eta).
+
+etaLeHalf(result, true) :-
+  eta_le_half(true).
+
+xBounds(result, bounds(K, L, U)) :-
+  index(K),
+  x_bounds(K, L, U).
+
+midpoint(result, midpoint(K, M, HalfW)) :-
+  index(K),
+  midpoint(K, M, HalfW).
+
+width(result, width(K, W)) :-
+  index(K),
+  width(K, W).
+
+gradientBounds(result, gradient(K, GL, GU)) :-
+  index(K),
+  g_bounds(K, GL, GU).
+
+stepBounds(result, step(K, PL, PU)) :-
+  index(K),
+  p_bounds(K, PL, PU).
+
+objectiveBounds(result, f(K, FL, FU)) :-
+  index(K),
+  f_lower(K, FL),
+  f_upper(K, FU).
+
+widthContractsAt(result, K) :-
+  width_contracts_at(K, true).

package/examples/eyelang/gdpr-compliance.pl

@@ -0,0 +1,69 @@
+% GDPR-style compliance check: purpose, basis, minimisation, safeguards, and export.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(status, 2).
+materialize(reason, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+% case_alpha is intended to pass; case_beta is intentionally incomplete.
+processing(case_alpha).
+processing(case_beta).
+
+purpose(case_alpha, care_coordination).
+purpose(case_beta, marketing).
+
+legal_basis(case_alpha, explicit_consent).
+% case_beta intentionally has no legal basis.
+
+minimized(case_alpha).
+not_minimized(case_beta).
+
+special_category(case_alpha, health_data).
+special_category(case_beta, health_data).
+
+safeguard(case_alpha, encryption).
+safeguard(case_alpha, access_logging).
+safeguard(case_beta, encryption).
+
+third_country_transfer(case_beta).
+adequacy_decision(case_alpha).
+
+% Compliance is decomposed into reusable checks so reasons can be reported.
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+has_required_basis(Case) :- legal_basis(Case, explicit_consent).
+has_required_basis(Case) :- legal_basis(Case, medical_care).
+
+has_health_safeguards(Case) :-
+  special_category(Case, health_data),
+  safeguard(Case, encryption),
+  safeguard(Case, access_logging).
+
+transfer_ok(Case) :- not(third_country_transfer(Case)).
+transfer_ok(Case) :- adequacy_decision(Case).
+
+compliant(Case) :-
+  processing(Case),
+  has_required_basis(Case),
+  minimized(Case),
+  has_health_safeguards(Case),
+  transfer_ok(Case).
+
+% Individual failure rules explain why a case is noncompliant.
+noncompliance_reason(Case, missing_legal_basis) :-
+  processing(Case),
+  not(has_required_basis(Case)).
+
+noncompliance_reason(Case, not_minimized) :-
+  not_minimized(Case).
+
+noncompliance_reason(Case, missing_access_logging) :-
+  special_category(Case, health_data),
+  not(safeguard(Case, access_logging)).
+
+noncompliance_reason(Case, transfer_without_adequacy) :-
+  third_country_transfer(Case),
+  not(adequacy_decision(Case)).
+
+status(Case, gdpr_compliant) :- compliant(Case).
+status(Case, gdpr_noncompliant) :- noncompliance_reason(Case, _Reason).
+reason(Case, Reason) :- noncompliance_reason(Case, Reason).

package/examples/eyelang/goldbach-1000.pl

@@ -0,0 +1,185 @@
+% Goldbach pairs up to 1000.
+% Prime numbers are input data; the rule below derives all Goldbach pairs.
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(isPrime, 2).
+materialize(goldbachOk, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+prime(2).
+prime(3).
+prime(5).
+prime(7).
+prime(11).
+prime(13).
+prime(17).
+prime(19).
+prime(23).
+prime(29).
+prime(31).
+prime(37).
+prime(41).
+prime(43).
+prime(47).
+prime(53).
+prime(59).
+prime(61).
+prime(67).
+prime(71).
+prime(73).
+prime(79).
+prime(83).
+prime(89).
+prime(97).
+prime(101).
+prime(103).
+prime(107).
+prime(109).
+prime(113).
+prime(127).
+prime(131).
+prime(137).
+prime(139).
+prime(149).
+prime(151).
+prime(157).
+prime(163).
+prime(167).
+prime(173).
+prime(179).
+prime(181).
+prime(191).
+prime(193).
+prime(197).
+prime(199).
+prime(211).
+prime(223).
+prime(227).
+prime(229).
+prime(233).
+prime(239).
+prime(241).
+prime(251).
+prime(257).
+prime(263).
+prime(269).
+prime(271).
+prime(277).
+prime(281).
+prime(283).
+prime(293).
+prime(307).
+prime(311).
+prime(313).
+prime(317).
+prime(331).
+prime(337).
+prime(347).
+prime(349).
+prime(353).
+prime(359).
+prime(367).
+prime(373).
+prime(379).
+prime(383).
+prime(389).
+prime(397).
+prime(401).
+prime(409).
+prime(419).
+prime(421).
+prime(431).
+prime(433).
+prime(439).
+prime(443).
+prime(449).
+prime(457).
+prime(461).
+prime(463).
+prime(467).
+prime(479).
+prime(487).
+prime(491).
+prime(499).
+prime(503).
+prime(509).
+prime(521).
+prime(523).
+prime(541).
+prime(547).
+prime(557).
+prime(563).
+prime(569).
+prime(571).
+prime(577).
+prime(587).
+prime(593).
+prime(599).
+prime(601).
+prime(607).
+prime(613).
+prime(617).
+prime(619).
+prime(631).
+prime(641).
+prime(643).
+prime(647).
+prime(653).
+prime(659).
+prime(661).
+prime(673).
+prime(677).
+prime(683).
+prime(691).
+prime(701).
+prime(709).
+prime(719).
+prime(727).
+prime(733).
+prime(739).
+prime(743).
+prime(751).
+prime(757).
+prime(761).
+prime(769).
+prime(773).
+prime(787).
+prime(797).
+prime(809).
+prime(811).
+prime(821).
+prime(823).
+prime(827).
+prime(829).
+prime(839).
+prime(853).
+prime(857).
+prime(859).
+prime(863).
+prime(877).
+prime(881).
+prime(883).
+prime(887).
+prime(907).
+prime(911).
+prime(919).
+prime(929).
+prime(937).
+prime(941).
+prime(947).
+prime(953).
+prime(967).
+prime(971).
+prime(977).
+prime(983).
+prime(991).
+prime(997).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+even_between_4_1000(N) :- between(4, 1000, N), mod(N, 2, 0).
+
+isPrime(N, true) :-
+  prime(N).
+
+goldbachOk(N, true) :-
+  even_between_4_1000(N),
+  goldbach_pair(N, _P, _Q).

package/examples/eyelang/good-cobbler.pl

@@ -0,0 +1,14 @@
+% Good cobbler, adapted from Eyeling's examples/good-cobbler.n3.
+%
+% The Eyeling result is a quoted assertion saying that joe is a good Cobbler.
+% Here the quoted assertion is represented as an eyelang term.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(is, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+assertedIs(joe, good(cobbler)).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+is(test, is(X, good(Y))) :-
+  assertedIs(X, good(Y)).

package/examples/eyelang/gps.pl

@@ -0,0 +1,152 @@
+% Memoize route paths because the same candidate routes are checked repeatedly
+% for explanation and verification relations.
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(recommendedRoute, 2).
+materialize(outcome, 2).
+materialize(statement, 3).
+materialize(label, 2).
+materialize(actionSequence, 2).
+materialize(durationSeconds, 2).
+materialize(cost, 2).
+materialize(belief, 2).
+materialize(comfort, 2).
+materialize(selectedRoute, 2).
+materialize(comparison, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+memoize(path, 7).
+memoize(traveller_path, 6).
+
+% GPS — ARC-style goal-driven route planning, translated from Eyeling's gps.n3.
+%
+% The map is kept as quoted formula data.  Rules project gps_description
+% statements from that formula, chain them into paths, compare the two complete
+% routes from Gent to Oostende, and produce a compact explanation report.
+
+case_graph(caseGraph, (
+  location(i1, gent),
+  text(question, "Which route should we take from Gent to Oostende?"),
+  label(routeDirect, "Gent -> Brugge -> Oostende"),
+  label(routeViaKortrijk, "Gent -> Kortrijk -> Brugge -> Oostende")
+)).
+
+map_graph(mapBE, (
+  gps_description(mapBE, description(location(S, gent), true, location(S, brugge), drive_gent_brugge, 1500.0, 0.006, 0.96, 0.99)),
+  gps_description(mapBE, description(location(S, gent), true, location(S, kortrijk), drive_gent_kortrijk, 1600.0, 0.007, 0.96, 0.99)),
+  gps_description(mapBE, description(location(S, kortrijk), true, location(S, brugge), drive_kortrijk_brugge, 1600.0, 0.007, 0.96, 0.99)),
+  gps_description(mapBE, description(location(S, brugge), true, location(S, oostende), drive_brugge_oostende, 900.0, 0.004, 0.98, 1.0))
+)).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+case_statement(S, P, O) :-
+  case_graph(caseGraph, Formula),
+  formula_binary(Formula, S, P, O).
+
+map_description(From, To, Action, Duration, Cost, Belief, Comfort) :-
+  map_graph(mapBE, Formula),
+  formula_binary(Formula, mapBE, gps_description, description(From, true, To, Action, Duration, Cost, Belief, Comfort)).
+
+path(From, To, [Action], Duration, Cost, Belief, Comfort) :-
+  map_description(From, To, Action, Duration, Cost, Belief, Comfort).
+
+path(From, To, Actions, Duration, Cost, Belief, Comfort) :-
+  map_description(From, Mid, Action, D1, C1, B1, F1),
+  path(Mid, To, RestActions, D2, C2, B2, F2),
+  append([Action], RestActions, Actions),
+  add(D1, D2, Duration),
+  add(C1, C2, Cost),
+  mul(B1, B2, Belief),
+  mul(F1, F2, Comfort).
+
+traveller_start(i1, location(i1, gent)).
+traveller_goal(i1, location(i1, oostende)).
+
+traveller_path(Traveller, Actions, Duration, Cost, Belief, Comfort) :-
+  traveller_start(Traveller, From),
+  traveller_goal(Traveller, To),
+  path(From, To, Actions, Duration, Cost, Belief, Comfort).
+
+route_metrics(routeDirect, Duration, Cost, Belief, Comfort) :-
+  traveller_path(i1, [drive_gent_brugge, drive_brugge_oostende], Duration, Cost, Belief, Comfort).
+
+route_metrics(routeViaKortrijk, Duration, Cost, Belief, Comfort) :-
+  traveller_path(i1, [drive_gent_kortrijk, drive_kortrijk_brugge, drive_brugge_oostende], Duration, Cost, Belief, Comfort).
+
+recommended_route(routeDirect) :-
+  route_metrics(routeDirect, DirectDuration, DirectCost, DirectBelief, DirectComfort),
+  route_metrics(routeViaKortrijk, ViaDuration, ViaCost, ViaBelief, ViaComfort),
+  lt(DirectDuration, ViaDuration),
+  lt(DirectCost, ViaCost),
+  gt(DirectBelief, ViaBelief),
+  gt(DirectComfort, ViaComfort).
+
+outcome(routeDirect, "Take the direct route via Brugge.").
+
+% Verification checks, analogous to the false-producing guards in gps.n3.
+check(c1, true) :-
+  traveller_path(i1, [drive_gent_brugge, drive_brugge_oostende], _, _, _, _).
+
+check(c2, true) :-
+  traveller_path(i1, [drive_gent_kortrijk, drive_kortrijk_brugge, drive_brugge_oostende], _, _, _, _).
+
+check(c3, true) :-
+  route_metrics(routeDirect, D1, _, _, _),
+  route_metrics(routeViaKortrijk, D2, _, _, _),
+  lt(D1, D2).
+
+check(c4, true) :-
+  route_metrics(routeDirect, _, C1, _, _),
+  route_metrics(routeViaKortrijk, _, C2, _, _),
+  lt(C1, C2).
+
+check(c5, true) :-
+  route_metrics(routeDirect, _, _, B1, F1),
+  route_metrics(routeViaKortrijk, _, _, B2, F2),
+  gt(B1, B2),
+  gt(F1, F2).
+
+recommendedRoute(decision, Route) :-
+  recommended_route(Route).
+
+outcome(decision, Outcome) :-
+  recommended_route(Route),
+  outcome(Route, Outcome).
+
+statement(check, Check, true) :-
+  check(Check, true).
+
+route_actions(routeDirect, [drive_gent_brugge, drive_brugge_oostende]).
+route_actions(routeViaKortrijk, [drive_gent_kortrijk, drive_kortrijk_brugge, drive_brugge_oostende]).
+
+% Derived route and report relations.  These are consequences of the route search
+% and comparison, not pre-written markdown output.
+label(Route, Label) :-
+  case_statement(Route, label, Label),
+  route_metrics(Route, _Duration, _Cost, _Belief, _Comfort).
+
+actionSequence(Route, Actions) :-
+  route_actions(Route, Actions),
+  route_metrics(Route, _Duration, _Cost, _Belief, _Comfort).
+
+durationSeconds(Route, Duration) :-
+  route_metrics(Route, Duration, _Cost, _Belief, _Comfort).
+
+cost(Route, Cost) :-
+  route_metrics(Route, _Duration, Cost, _Belief, _Comfort).
+
+belief(Route, Belief) :-
+  route_metrics(Route, _Duration, _Cost, Belief, _Comfort).
+
+comfort(Route, Comfort) :-
+  route_metrics(Route, _Duration, _Cost, _Belief, Comfort).
+
+selectedRoute(report, route(Route, Actions, Duration, Cost, Belief, Comfort)) :-
+  recommended_route(Route),
+  route_actions(Route, Actions),
+  route_metrics(Route, Duration, Cost, Belief, Comfort).
+
+comparison(report, dominates(routeDirect, routeViaKortrijk)) :-
+  recommended_route(routeDirect),
+  check(c3, true),
+  check(c4, true),
+  check(c5, true).

package/examples/eyelang/graph-reachability.pl

@@ -0,0 +1,36 @@
+% Graph reachability example adapted from Eyelet input/graph-reachability.pl.
+%
+% The original uses Prolog negation and member/2 to avoid revisiting nodes.
+% eyelang expresses the same finite search with not(member(...)).
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(reachable, 2).
+materialize(not_reachable, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+edge(a, b).
+edge(a, c).
+edge(b, d).
+edge(c, e).
+edge(d, f).
+edge(e, f).
+edge(f, g).
+
+reachable(Node, Node, _Visited).
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+reachable(Start, Goal, Visited) :-
+  edge(Start, Next),
+  not(member(Next, Visited)),
+  reachable(Next, Goal, [Next|Visited]).
+
+is_reachable(Start, Goal) :-
+  reachable(Start, Goal, [Start]).
+
+reachable(reachability_case, path(a, f)) :-
+  is_reachable(a, f).
+
+reachable(reachability_case, path(c, g)) :-
+  is_reachable(c, g).
+
+not_reachable(reachability_case, path(b, e)) :-
+  not(is_reachable(b, e)).

package/examples/eyelang/gray-code-counter.pl

@@ -0,0 +1,48 @@
+% Gray-code counter adapted from Eyeling gray-code-counter.n3 and the
+% Clause and Effect example referenced there.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(isgcc, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+% Boolean gates are truth tables; the circuit rules compose them.
+and(0, 0, 0). and(0, 1, 0). and(1, 0, 0). and(1, 1, 1).
+or(0, 0, 0).  or(0, 1, 1).  or(1, 0, 1).  or(1, 1, 1).
+inv(0, 1). inv(1, 0).
+
+dff(D, 0, Q, Q).
+dff(D, 1, _Q, D).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+neta(A, B, Q) :-
+  and(A, B, T1),
+  inv(A, NA),
+  inv(B, NB),
+  and(NA, NB, T2),
+  or(T1, T2, Q).
+
+netb(A, B, C, Q1, Q2) :-
+  and(A, C, T1),
+  inv(C, NC),
+  and(B, NC, T2),
+  inv(A, NA),
+  and(NA, C, T3),
+  or(T1, T2, Q1),
+  or(T2, T3, Q2).
+
+% One clock step computes D inputs, then updates the three flip-flops.
+gcc(C, [Qa, Qb, Qc], [Za, Zb, Zc]) :-
+  netb(Qa, Qb, Qc, D1, D2),
+  neta(Qa, Qb, D3),
+  dff(D1, C, Qa, Za),
+  dff(D2, C, Qb, Zb),
+  dff(D3, C, Qc, Zc).
+
+% testgcc/3 runs the circuit over a list of clock inputs.
+testgcc([], _State, []).
+testgcc([C|Cs], State, [Next|Rest]) :-
+  gcc(C, State, Next),
+  testgcc(Cs, Next, Rest).
+
+isgcc([[1, 1, 1, 1, 1, 1, 1, 1, 1], [0, 0, 0]], States) :-
+  testgcc([1, 1, 1, 1, 1, 1, 1, 1, 1], [0, 0, 0], States).

package/examples/eyelang/greatest-lower-bound-uniqueness.pl

@@ -0,0 +1,28 @@
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(sameGreatestLowerBound, 4).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+% Greatest-lower-bound uniqueness example adapted from Eyeling
+% greatest-lower-bound-uniqueness.n3.
+% If M and N are both greatest lower bounds of A and B, each is below the other;
+% antisymmetry is represented by the ordinary derived relation sameTerm/2.
+
+glbOf(g1, a, b).
+glbOf(g2, a, b).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+lowerBoundOf(M, A, B) :- glbOf(M, A, B).
+
+leq(L, M) :-
+  glbOf(M, A, B),
+  lowerBoundOf(L, A, B).
+
+sameTerm(M, N) :-
+  leq(M, N),
+  leq(N, M).
+
+sameGreatestLowerBound(A, B, M, N) :-
+  glbOf(M, A, B),
+  glbOf(N, A, B),
+  sameTerm(M, N),
+  neq(M, N).