eyeprolog 0.5.3

package/examples/gd-step-certified.pl

@@ -0,0 +1,164 @@
+% Memoize interval computations reused across width, midpoint, gradient, step,
+% objective, and contraction report relations.
+% Output declarations: host-supplied goals select the relations written to this example's golden output.
+%
+% This is a proof-friendly optimization trace: every numeric fact needed to
+% justify the step is queried, so proof output can certify why the update
+% is accepted.
+%% goal: eta(X0, X1)
+
+%% goal: etaLeHalf(X0, X1)
+
+%% goal: xBounds(X0, X1)
+
+%% goal: midpoint(X0, X1)
+
+%% goal: width(X0, X1)
+
+%% goal: gradientBounds(X0, X1)
+
+%% goal: stepBounds(X0, X1)
+
+%% goal: objectiveBounds(X0, X1)
+
+%% goal: widthContractsAt(X0, X1)
+
+
+% Program structure: facts set up the scenario, and rules derive the queried conclusions.
+
+% 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) :- (Eta is 1.0 / 5).
+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),
+  (Dl is L - A),
+  (Du is U - A),
+  (Gl is 2 * Dl),
+  (Gu is 2 * Du).
+
+p_bounds(K, Pl, Pu) :-
+  eta(Eta),
+  g_bounds(K, Gl, Gu),
+  (Pl is Eta * Gl),
+  (Pu is Eta * Gu).
+
+x_bounds(K1, L1, U1) :-
+  previous(K1, K),
+  x_bounds(K, L, U),
+  target(A),
+  eta(Eta),
+  (Dl is L - A),
+  (Du is U - A),
+  (Gl is 2 * Dl),
+  (Gu is 2 * Du),
+  (Pl is Eta * Gl),
+  (Pu is Eta * Gu),
+  (L1 is L - Pu),
+  (U1 is U - Pl).
+
+width(K, W) :-
+  x_bounds(K, L, U),
+  (W is U - L).
+
+midpoint(K, M, Halfw) :-
+  x_bounds(K, L, U),
+  width(K, W),
+  (Halfw is W / 2),
+  (Sum is L + U),
+  (M is Sum / 2).
+
+eta_le_half(true) :-
+  eta(Eta),
+  (Half is 1.0 / 2),
+  (Eta =< Half).
+
+width_contracts_at(K1, true) :-
+  eta_le_half(true),
+  previous(K1, K),
+  width(K, W),
+  width(K1, W1),
+  (W1 =< W).
+
+max2(A, B, A) :- (A >= B).
+max2(A, B, B) :- (A < B).
+min2(A, B, A) :- (A =< B).
+min2(A, B, B) :- (A > B).
+
+end_squares(K, Sl, Su) :-
+  target(A),
+  x_bounds(K, L, U),
+  (Dl is L - A),
+  (Du is U - A),
+  (Sl is Dl * Dl),
+  (Su is Du * Du).
+
+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),
+  (L =< A),
+  (A =< U).
+
+f_lower(K, Fl) :-
+  target(A),
+  x_bounds(K, L, U),
+  (U < A),
+  end_squares(K, Sl, Su),
+  min2(Sl, Su, Fl).
+
+f_lower(K, Fl) :-
+  target(A),
+  x_bounds(K, L, U),
+  (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/gdpr-compliance.pl

@@ -0,0 +1,71 @@
+% GDPR-style compliance check.
+% Each processing case is tested for purpose compatibility, legal basis,
+% minimisation, special-category safeguards, and international-transfer safety.
+% Separate failure rules produce concise reasons for noncompliant cases.
+
+%% goal: status(X0, X1)
+
+%% goal: reason(X0, X1)
+
+
+% 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.
+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) :- \+ 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),
+  \+ has_required_basis(Case).
+
+noncompliance_reason(Case, not_minimized) :-
+  not_minimized(Case).
+
+noncompliance_reason(Case, missing_access_logging) :-
+  special_category(Case, health_data),
+  \+ safeguard(Case, access_logging).
+
+noncompliance_reason(Case, transfer_without_adequacy) :-
+  third_country_transfer(Case),
+  \+ 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/goldbach.pl

@@ -0,0 +1,49 @@
+% Goldbach's_conjecture
+% See https://en.wikipedia.org/wiki/Goldbach%27s_conjecture:
+% every positive even number greater than 2 is the sum of two prime numbers
+
+goldbach(4, [2, 2]).
+goldbach(N, L) :-
+    0 =:= N rem 2,
+    N > 4,
+    goldb(N, L, 3).
+
+goldb(N, [P, Q], P) :-
+    Q is N-P,
+    is_prime(Q),
+    !.
+goldb(N, L, P) :-
+    P < N,
+    next_prime(P, P1),
+    goldb(N, L, P1).
+
+next_prime(P, P1) :-
+    P1 is P+2,
+    is_prime(P1),
+    !.
+next_prime(P, P1) :-
+    P2 is P+2,
+    next_prime(P2, P1).
+
+is_prime(2).
+is_prime(3).
+is_prime(P) :-
+    P > 3,
+    1 =:= P rem 2,
+    smallest_divisor_from(P, 3, P).
+
+has_factor(N, L) :-
+    0 =:= N rem L,
+    !.
+has_factor(N, L) :-
+    L*L <  N,
+    L2 is L+2,
+    has_factor(N, L2).
+
+% query
+case(N, G) :-
+    between(2, 35, I),
+    N is 2^I,
+    goldbach(N, G).
+%% goal: case(_, _)
+

package/examples/good-cobbler.pl

@@ -0,0 +1,17 @@
+% 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 a eyeprolog term.
+
+% Output declarations: host-supplied goals select the relations written to this example's golden output.
+%% goal: holds_result(X0, X1)
+
+
+% The asserted fact is kept separate from the output form so the rule can show
+% how a quoted Eyeling assertion maps to an ordinary eyeprolog term.
+assertedIs(joe, good(cobbler)).
+
+% The single rule is intentionally simple: it preserves the subject and
+% profession while wrapping the conclusion as holds_result(X, good(Y)).
+holds_result(test, holds_result(X, good(Y))) :-
+  assertedIs(X, good(Y)).

package/examples/gps.pl

@@ -0,0 +1,161 @@
+% GPS route-planning example translated from Eyeling's gps.n3.
+% The map is stored as quoted formula data and projected with ordinary term
+% traversal and =../2. Route
+% paths accumulate action sequence, duration, cost, belief, and comfort; table
+% keeps repeated comparison and explanation queries from recomputing paths.
+
+%% goal: recommendedRoute(X0, X1)
+
+%% goal: outcome(X0, X1)
+
+%% goal: statement(X0, X1, X2)
+
+%% goal: label(X0, X1)
+
+%% goal: actionSequence(X0, X1)
+
+%% goal: durationSeconds(X0, X1)
+
+%% goal: cost(X0, X1)
+
+%% goal: belief(X0, X1)
+
+%% goal: comfort(X0, X1)
+
+%% goal: selectedRoute(X0, X1)
+
+%% goal: comparison(X0, X1)
+
+
+
+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))
+)).
+
+context_member((Left, _right), Member) :- context_member(Left, Member).
+context_member((_left, Right), Member) :- context_member(Right, Member).
+context_member(Member, Member) :- Member \= (_left, _right).
+
+case_statement(S, P, O) :-
+  case_graph(caseGraph, Context),
+  context_member(Context, Statement),
+  (Statement =.. [P, S, O]).
+
+map_description(From, To, Action, Duration, Cost, Belief, Comfort) :-
+  map_graph(mapBE, Context),
+  context_member(Context, gps_description(mapBE, 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),
+  (Duration is D1 + D2),
+  (Cost is C1 + C2),
+  (Belief is B1 * B2),
+  (Comfort is F1 * F2).
+
+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),
+  (Directduration < Viaduration),
+  (Directcost < Viacost),
+  (Directbelief > Viabelief),
+  (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, _, _, _),
+  (D1 < D2).
+
+check(c4, true) :-
+  route_metrics(routeDirect, _, C1, _, _),
+  route_metrics(routeViaKortrijk, _, C2, _, _),
+  (C1 < C2).
+
+check(c5, true) :-
+  route_metrics(routeDirect, _, _, B1, F1),
+  route_metrics(routeViaKortrijk, _, _, B2, F2),
+  (B1 > B2),
+  (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/graph-reachability.pl

@@ -0,0 +1,35 @@
+% Graph reachability example adapted from Eyelet input/graph-reachability.pl.
+% The recursive search carries a Visited list and rejects already-seen nodes with
+% not(member(...)).  This keeps reachability finite and also lets the example
+% derive explicit not_reachable/2 evidence for a negative test case.
+
+%% goal: reachable(X0, X1)
+
+%% goal: not_reachable(X0, X1)
+
+
+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).
+reachable(Start, Goal, Visited) :-
+  edge(Start, Next),
+  \+ 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)) :-
+  \+ is_reachable(b, e).

package/examples/graph.pl

@@ -0,0 +1,36 @@
+% Transitive graph paths over a small map of French cities.
+%
+% The base relation is directed: oneway(A, B) means there is a road from A
+% to B.  The derived relation path(A, B) is the transitive closure: B is
+% reachable from A by one or more directed legs.
+%
+% The recursive rule is written in a productive, right-recursive form:
+%
+%     path(A, C) :- oneway(A, B), path(B, C).
+%
+% That order matters in a goal-directed reasoner.  A left-recursive closure
+% rule such as `path(A, C) :- path(A, B), path(B, C).` starts by asking for
+% the same open relation it is currently proving, so eyeprolog's recursion guard
+% must stop it to avoid an infinite loop.  The result is under-generation: only
+% direct edges are printed.  Starting with the concrete generator `oneway/2`
+% first makes each recursive step smaller and yields the complete closure.
+
+%% goal: path(X0, X1)
+
+
+oneway(paris, orleans).
+oneway(paris, chartres).
+oneway(paris, amiens).
+oneway(orleans, blois).
+oneway(orleans, bourges).
+oneway(blois, tours).
+oneway(chartres, lemans).
+oneway(lemans, angers).
+oneway(lemans, tours).
+oneway(angers, nantes).
+
+path(A, B) :-
+    oneway(A, B).
+path(A, C) :-
+    oneway(A, B),
+    path(B, C).

package/examples/gray-code-counter.pl

@@ -0,0 +1,48 @@
+% Gray-code counter adapted from Eyeling gray-code-counter.n3.
+% Boolean gates are represented as truth-table facts.  The circuit rules compose
+% those gates into next-state logic for three flip-flops, and testgcc/3 runs the
+% counter over a finite clock sequence.
+
+%% goal: isgcc(X0, X1)
+
+
+% 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).
+
+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/greatest-lower-bound-uniqueness.pl

@@ -0,0 +1,31 @@
+% Order-theory proof sketch: greatest lower bounds are unique.
+%
+% Two candidate GLBs are asserted for the same pair.  The rules derive that
+% each must be below the other, then use antisymmetry-style sameTerm/2 reasoning
+% to report that the candidates denote the same lower bound.
+%% goal: sameGreatestLowerBound(X0, X1, X2, X3)
+
+
+% Adapted from Eyeling greatest-lower-bound-uniqueness.n3.  The named facts
+% intentionally use two different symbols, g1 and g2, so the final output shows
+% the equality-style conclusion as an explicit derived relation.
+
+glbOf(g1, a, b).
+glbOf(g2, a, b).
+
+% leq/2 captures the defining property of a GLB: every lower bound is below it.
+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),
+  (M \= N).

package/examples/group-inverse-uniqueness.pl

@@ -0,0 +1,37 @@
+% Group inverse uniqueness, adapted from Eyeling's examples/group-inverse-uniqueness.n3.
+%
+% The output mirrors the Eyeling golden result shape:
+% sameInverse(x, i, j) and sameInverse(x, j, i).
+
+% Output declarations: host-supplied goals select the relations written to this example's golden output.
+%% goal: sameInverse(X0, X1, X2)
+
+
+% The group table is deliberately tiny: e is the identity, and i and j are
+% two names that both behave as the inverse of x.
+element(e).
+element(x).
+element(i).
+element(j).
+
+% leftInverse/2 and rightInverse/2 are proved from op/3.  sameInverse/3
+% then derives uniqueness by combining both inverse directions with sameTerm/2.
+op(e, X, X) :- element(X).
+op(X, e, X) :- element(X).
+op(i, x, e).
+op(x, j, e).
+op(j, x, e).
+op(x, i, e).
+
+sameTerm(X, X) :- element(X).
+sameTerm(i, j).
+sameTerm(j, i).
+
+leftInverse(A, B) :- op(B, A, e).
+rightInverse(A, B) :- op(A, B, e).
+
+sameInverse(A, B, C) :-
+  leftInverse(A, B),
+  rightInverse(A, C),
+  sameTerm(B, C),
+  (B \= C).

package/examples/hamiltonian-path.pl

@@ -0,0 +1,52 @@
+% Hamiltonian path, adapted from Eyelet's input/hamiltonian-path.pl.
+%
+% The graph is the same six-vertex undirected graph.  eyeprolog spells the finite
+% vertex set directly and derives every path that visits each vertex exactly
+% once.
+
+% Output declarations: host-supplied goals select the relations written to this example's golden output.
+%% goal: hasHamiltonianPath(X0, X1)
+
+%% goal: hamiltonianPath(X0, X1)
+
+
+% The finite six-vertex graph is small enough to search directly.  adjacent/2
+% is tabled because every candidate path repeatedly asks the same edge tests.
+
+edge(v1, v2).
+edge(v1, v3).
+edge(v1, v5).
+edge(v1, v6).
+edge(v2, v3).
+edge(v2, v4).
+edge(v2, v6).
+edge(v3, v4).
+edge(v3, v6).
+edge(v4, v5).
+edge(v4, v6).
+
+% hamiltonian_path/1 is intentionally unrolled to six positions: each next
+% vertex must be adjacent to the previous one and absent from the prefix.
+adjacent(V, U) :- edge(V, U).
+adjacent(V, U) :- edge(U, V).
+
+vertex(v1).
+vertex(v2).
+vertex(v3).
+vertex(v4).
+vertex(v5).
+vertex(v6).
+
+hamiltonian_path([A, B, C, D, E, F]) :-
+  vertex(A),
+  vertex(B), adjacent(A, B), \+ member(B, [A]),
+  vertex(C), adjacent(B, C), \+ member(C, [A, B]),
+  vertex(D), adjacent(C, D), \+ member(D, [A, B, C]),
+  vertex(E), adjacent(D, E), \+ member(E, [A, B, C, D]),
+  vertex(F), adjacent(E, F), \+ member(F, [A, B, C, D, E]).
+
+hasHamiltonianPath(graph, true) :-
+  hamiltonian_path(_path).
+
+hamiltonianPath(graph, Path) :-
+  hamiltonian_path(Path).