eyeprolog 0.5.3

package/examples/truth-maintenance-system.pl

@@ -0,0 +1,65 @@
+% A tiny assumption-based truth maintenance system.
+%
+% An environment is a set of assumptions.  Justifications derive beliefs from
+% assumptions and from other derived beliefs.  The TMS can therefore explain
+% which environments support a belief and which environments are inconsistent
+% because they support contradictory conclusions.
+
+%% goal: tmsSupport(X0, X1)
+
+%% goal: tmsJustification(X0, X1, X2)
+
+%% goal: tmsInconsistent(X0)
+
+%% goal: tmsConclusion(X0, X1)
+
+
+
+% Candidate environments.
+environment(clear_only, [sensor_clear]).
+environment(blocked_only, [sensor_blocked]).
+environment(conflicting_sensors, [sensor_clear, sensor_blocked]).
+environment(override_blocked, [sensor_blocked, operator_override]).
+
+assumes(Environment, Assumption) :-
+  environment(Environment, Assumptions),
+  member(Assumption, Assumptions).
+
+% Justifications.  Preconditions are either assumption(Name) or another derived
+% belief.  The last justification says an operator override can permit motion
+% even when the blocked-path belief is also present.
+justification(j_clear_path, [assumption(sensor_clear)], clear_path).
+justification(j_blocked_path, [assumption(sensor_blocked)], blocked_path).
+justification(j_permit_from_clear, [clear_path], permit_go).
+justification(j_forbid_from_blocked, [blocked_path], forbid_go).
+justification(j_override, [assumption(operator_override), blocked_path], permit_go).
+
+all_hold(_, []).
+all_hold(Environment, [assumption(Assumption) | Rest]) :-
+  assumes(Environment, Assumption),
+  all_hold(Environment, Rest).
+all_hold(Environment, [Belief | Rest]) :-
+  supported(Environment, Belief),
+  all_hold(Environment, Rest).
+
+supported(Environment, Belief) :-
+  justification(_, Preconditions, Belief),
+  all_hold(Environment, Preconditions).
+
+contradicts(permit_go, forbid_go).
+contradicts(forbid_go, permit_go).
+inconsistent(Environment) :-
+  supported(Environment, Left),
+  supported(Environment, Right),
+  contradicts(Left, Right).
+
+% Show the actual justifications that fired, not just the final supported beliefs.
+fires(Environment, Justification, Belief) :-
+  justification(Justification, Preconditions, Belief),
+  all_hold(Environment, Preconditions).
+
+tmsSupport(Environment, Belief) :- supported(Environment, Belief).
+tmsJustification(Environment, Justification, Belief) :- fires(Environment, Justification, Belief).
+tmsInconsistent(Environment) :- inconsistent(Environment).
+tmsConclusion(case, "truth maintenance separates support from consistency across assumption environments") :-
+  inconsistent(conflicting_sensors).

package/examples/turing.pl

@@ -0,0 +1,72 @@
+% Universal Turing machine example adapted from Eyelet's input/turing.pl.
+%
+% The machine below adds 1 to a binary number represented as a list of bits.
+% A tape is split into a reversed left side, current cell, and right side; move/7
+% updates that zipper representation.  The blank tape symbol is #.
+
+% Output declarations: host-supplied goals select the relations written to this example's golden output.
+%% goal: input(X0, X1)
+
+%% goal: output(X0, X1)
+
+%% goal: addsOne(X0, X1)
+
+
+% compute/2 initializes the tape and starts from the machine's start state.
+compute([], Outtape) :-
+  start(_machine, I),
+  find(I, [], #, [], Outtape).
+
+compute([Head|Tail], Outtape) :-
+  start(_machine, I),
+  find(I, [], Head, Tail, Outtape).
+
+% find/5 executes one transition, moves the head, and either halts or recurses.
+find(State, Left, Cell, Right, Outtape) :-
+  t([State, Cell, Write, Move], Next),
+  move(Move, Left, Write, Right, A, B, C),
+  continue(Next, A, B, C, Outtape).
+
+continue(halt, Left, Cell, Right, Outtape) :-
+  rever(Left, R),
+  append(R, [Cell|Right], Outtape).
+
+continue(State, Left, Cell, Right, Outtape) :-
+  find(State, Left, Cell, Right, Outtape).
+
+% Head movement defines the tape zipper update, including blank extension.
+move(l, [], Cell, Right, [], #, [Cell|Right]).
+move(l, [Head|Tail], Cell, Right, Tail, Head, [Cell|Right]).
+move(s, Left, Cell, Right, Left, Cell, Right).
+move(r, Left, Cell, [], [Cell|Left], #, []).
+move(r, Left, Cell, [Head|Tail], [Cell|Left], Head, Tail).
+
+rever([], []).
+rever([A|B], C) :-
+  rever(B, D),
+  append(D, [A], C).
+
+% A Turing machine to add 1 to a binary number.
+start(add1, 0).
+t([0, 0, 0, r], 0).
+t([0, 1, 1, r], 0).
+t([0, #, #, l], 1).
+t([1, 0, 1, s], halt).
+t([1, 1, 0, l], 1).
+t([1, #, 1, s], halt).
+
+case(case1, [1, 0, 1, 0, 0, 1]).
+case(case2, [1, 0, 1, 1, 1, 1]).
+case(case3, [1, 1, 1, 1, 1, 1]).
+case(case4, []).
+
+input(Case, Intape) :-
+  case(Case, Intape).
+
+output(Case, Outtape) :-
+  case(Case, Intape),
+  compute(Intape, Outtape).
+
+addsOne(Case, true) :-
+  case(Case, Intape),
+  compute(Intape, _outtape).

package/examples/type-inference.pl

@@ -0,0 +1,59 @@
+% Hindley-Milner-style type inference for a tiny lambda language.
+%
+% The example is intentionally small and deterministic.  Lambda binders carry
+% explicit type variables or annotations, and ordinary logic unification solves
+% the constraints created by application, arithmetic, conditionals, and pairs.
+% The symbolic names t0, t1, and t2 stand for schematic type variables in the
+% displayed answers; concrete examples such as apply_id annotate the argument as
+% int so the application can be checked.
+%% goal: type_answer(X0, X1)
+
+%% goal: type_reason(X0, X1)
+
+
+
+% Tiny expression language: int_lit/1, bool_lit/1, var/1, lam/3, app/2,
+% add/2, if/3, pair/2, fst/1, and snd/1.
+program(id, lam(x, t0, var(x))).
+program(const, lam(x, t0, lam(y, t1, var(x)))).
+program(apply_id, app(lam(x, int, var(x)), int_lit(42))).
+program(compose,
+  lam(f, fun(t1, t2),
+    lam(g, fun(t0, t1),
+      lam(x, t0,
+        app(var(f), app(var(g), var(x))))))).
+program(branch,
+  if(bool_lit(true), add(int_lit(20), int_lit(22)), int_lit(0))).
+program(first_of_pair, fst(pair(bool_lit(true), int_lit(7)))).
+
+lookup(Name, [[Name, Type] | _], Type).
+lookup(Name, [[_, _] | Rest], Type) :- lookup(Name, Rest, Type).
+
+type_expr(_, int_lit(_), int).
+type_expr(_, bool_lit(_), bool).
+type_expr(Env, var(Name), Type) :- lookup(Name, Env, Type).
+type_expr(Env, lam(Name, Arg_type, Body), fun(Arg_type, Body_type)) :-
+  type_expr([[Name, Arg_type] | Env], Body, Body_type).
+type_expr(Env, app(Fn, Arg), Result_type) :-
+  type_expr(Env, Fn, fun(Arg_type, Result_type)),
+  type_expr(Env, Arg, Arg_type).
+type_expr(Env, add(Left, Right), int) :-
+  type_expr(Env, Left, int),
+  type_expr(Env, Right, int).
+type_expr(Env, if(Cond, Then, Else), Type) :-
+  type_expr(Env, Cond, bool),
+  type_expr(Env, Then, Type),
+  type_expr(Env, Else, Type).
+type_expr(Env, pair(Left, Right), pair(Left_type, Right_type)) :-
+  type_expr(Env, Left, Left_type),
+  type_expr(Env, Right, Right_type).
+type_expr(Env, fst(Pair), Left_type) :-
+  type_expr(Env, Pair, pair(Left_type, _)).
+type_expr(Env, snd(Pair), Right_type) :-
+  type_expr(Env, Pair, pair(_, Right_type)).
+
+type_answer(Name, Type) :- program(Name, Expr), type_expr([], Expr, Type).
+type_reason(compose, "application unifies f with t1 -> t2 and g with t0 -> t1") :-
+  type_answer(compose, _).
+type_reason(apply_id, "the identity function's parameter type is unified with int") :-
+  type_answer(apply_id, int).

package/examples/uuid.pl

@@ -0,0 +1,18 @@
+% uuid/1 creates exactly one fresh version 4 UUID atom.
+%
+% The UUID itself varies between runs, so this example checks its type and
+% canonical shape while returning a stable, reviewable answer.
+
+%% goal: uuid_example(Result)
+
+uuid_example(true) :-
+  uuid(UUID),
+  atom(UUID),
+  atom_length(UUID, 36),
+  sub_atom(UUID, 8, 1, 27, '-'),
+  sub_atom(UUID, 13, 1, 22, '-'),
+  sub_atom(UUID, 14, 1, 21, '4'),
+  sub_atom(UUID, 18, 1, 17, '-'),
+  sub_atom(UUID, 19, 1, 16, Variant),
+  member(Variant, ['8', '9', a, b]),
+  sub_atom(UUID, 23, 1, 12, '-').

package/examples/vector-similarity.pl

@@ -0,0 +1,64 @@
+% Vector dot product, Euclidean norm, and cosine similarity.
+%
+% Recursive list folds compute the dot product and squared-length sums.  The
+% public cosineSimilarity/2 report then combines those folds as
+% dot(A,B)/(norm(A)*norm(B)) for a named vector pair.
+%
+% The example keeps vectors as ordinary EyeProlog lists, so it doubles as a compact
+% demonstration of numeric recursion over list structure.
+
+%% goal: dotProduct(X0, X1)
+
+%% goal: normA(X0, X1)
+
+%% goal: normB(X0, X1)
+
+%% goal: cosineSimilarity(X0, X1)
+
+
+% Two named vectors form the single cosine-similarity case.
+vector(pair1, a, [1.0, 2.0, 3.0]).
+vector(pair1, b, [4.0, -5.0, 6.0]).
+
+% Recursive list folds compute dot products and sums of squares.
+dot([], [], 0.0).
+dot([A|As], [B|Bs], Dot) :-
+  (Product is A * B),
+  dot(As, Bs, Rest),
+  (Dot is Product + Rest).
+
+sum_squares([], 0.0).
+sum_squares([X|Xs], Total) :-
+  (Squared is X ** 2.0),
+  sum_squares(Xs, Rest),
+  (Total is Squared + Rest).
+
+norm(Vector, Norm) :-
+  sum_squares(Vector, Sumsquares),
+  (Norm is Sumsquares ** 0.5).
+
+% cosine = dot(A,B) / (norm(A) * norm(B)).
+cosine_similarity(Case, Similarity) :-
+  vector(Case, a, A),
+  vector(Case, b, B),
+  dot(A, B, Dot),
+  norm(A, Norma),
+  norm(B, Normb),
+  (Denominator is Norma * Normb),
+  (Similarity is Dot / Denominator).
+
+dotProduct(Case, Dot) :-
+  vector(Case, a, A),
+  vector(Case, b, B),
+  dot(A, B, Dot).
+
+normA(Case, Norma) :-
+  vector(Case, a, A),
+  norm(A, Norma).
+
+normB(Case, Normb) :-
+  vector(Case, b, B),
+  norm(B, Normb).
+
+cosineSimilarity(Case, Similarity) :-
+  cosine_similarity(Case, Similarity).

package/examples/vulnerability-impact.pl

@@ -0,0 +1,74 @@
+% Vulnerability impact analysis over a transitive dependency graph.
+% Services inherit exposure through direct and bounded transitive dependencies.
+% High-CVSS vulnerable packages derive risk and mitigation facts; critical
+% services additionally receive urgent patch recommendations.
+
+%% goal: uses(X0, X1)
+
+%% goal: impacted_by(X0, X1)
+
+%% goal: risk(X0, X1)
+
+%% goal: mitigate(X0, X1)
+
+%% goal: urgent_patch(X0, X1)
+
+
+service(webapp).
+service(worker).
+service(frontend).
+
+critical(webapp).
+critical(worker).
+
+depends_on(webapp, api).
+depends_on(worker, queue).
+depends_on(frontend, ui).
+depends_on(api, auth).
+depends_on(auth, openssl).
+depends_on(queue, openssl).
+depends_on(ui, css).
+
+vulnerability(openssl, cve_2026_0001).
+cvss(cve_2026_0001, 9.8).
+fixed_by(cve_2026_0001, openssl_3_0_14).
+
+vulnerability(css, cve_2026_0002).
+cvss(cve_2026_0002, 5.4).
+fixed_by(cve_2026_0002, css_2_1_1).
+
+uses(Service, Dependency) :-
+  service(Service),
+  depends_on(Service, Dependency).
+
+uses(Service, Dependency) :-
+  service(Service),
+  depends_on(Service, Intermediate),
+  depends_on(Intermediate, Dependency).
+
+uses(Service, Dependency) :-
+  service(Service),
+  depends_on(Service, Intermediate),
+  depends_on(Intermediate, Next),
+  depends_on(Next, Dependency).
+
+impacted_by(Service, Dependency) :-
+  uses(Service, Dependency).
+
+% exposed_to/2 connects dependency reachability to high-severity CVEs.
+exposed_to(Service, Vulnerability) :-
+  uses(Service, Package),
+  vulnerability(Package, Vulnerability),
+  cvss(Vulnerability, Score),
+  (Score > 7.0).
+
+risk(Service, high) :-
+  exposed_to(Service, _vulnerability).
+
+mitigate(Service, Vulnerability) :-
+  exposed_to(Service, Vulnerability).
+
+urgent_patch(Service, Patch) :-
+  critical(Service),
+  exposed_to(Service, Vulnerability),
+  fixed_by(Vulnerability, Patch).

package/examples/web-names.pl

@@ -0,0 +1,40 @@
+% Web names as first-class EyeProlog atoms.
+%
+% Angle-bracket IRI atoms are ordinary atoms with globally meaningful names.
+% They are self-contained, require no prefix declarations, and can be joined
+% directly across rules just like any other atom.
+
+%% goal: affiliated_with(X0, X1)
+
+%% goal: project_contact(X0, X1, X2)
+
+
+
+% A tiny graph using absolute IRI atoms directly.
+triple('<https://data.ugent.be/id/josd>', '<https://schema.org/name>', "Jos De Roo").
+triple('<https://data.ugent.be/id/josd>', '<https://schema.org/email>', "josderoo@gmail.com").
+triple('<https://data.ugent.be/id/josd>', '<https://schema.org/affiliation>', '<https://data.ugent.be/id/idlab>').
+triple('<https://data.ugent.be/id/idlab>', '<https://schema.org/parentOrganization>', '<https://data.ugent.be/id/ugent>').
+
+triple('<https://github.com/eyereasoner/eyeprolog>', '<https://schema.org/name>', "eyeprolog").
+triple('<https://github.com/eyereasoner/eyeprolog>', '<https://schema.org/codeRepository>', '<https://github.com/eyereasoner/eyeprolog>').
+triple('<https://github.com/eyereasoner/eyeprolog>', '<https://schema.org/maintainer>', '<https://data.ugent.be/id/josd>').
+
+% Organization membership follows parentOrganization links transitively.
+parent_organization(Unit, Org) :-
+    triple(Unit, '<https://schema.org/parentOrganization>', Org).
+parent_organization(Unit, Org) :-
+    triple(Unit, '<https://schema.org/parentOrganization>', Mid),
+    parent_organization(Mid, Org).
+
+affiliated_with(Person, Org) :-
+    triple(Person, '<https://schema.org/affiliation>', Org).
+affiliated_with(Person, Org) :-
+    triple(Person, '<https://schema.org/affiliation>', Unit),
+    parent_organization(Unit, Org).
+
+% A project contact is derived by joining the project's maintainer with the
+% maintainer's email.  The join works because both facts use the same IRI atom.
+project_contact(Project, Person, Email) :-
+    triple(Project, '<https://schema.org/maintainer>', Person),
+    triple(Person, '<https://schema.org/email>', Email).

package/examples/weighted-interval-scheduling.pl

@@ -0,0 +1,81 @@
+% Weighted interval scheduling via automatically tabled dynamic programming.
+%
+% Intervals are ordered by finish time.  best_from(I,Best) compares the two
+% choices at position I: skip it, or take it and jump to the next compatible
+% interval.  chosen_from/2 then walks the cached decisions to report a schedule.
+%% goal: weighted_interval_answer(X0, X1)
+
+
+
+last_interval(8).
+sentinel(9).
+
+interval(1, 1, 4, 5).
+interval(2, 3, 5, 1).
+interval(3, 0, 6, 8).
+interval(4, 4, 7, 4).
+interval(5, 3, 9, 6).
+interval(6, 5, 9, 3).
+interval(7, 6, 10, 2).
+interval(8, 8, 11, 4).
+
+% Find the earliest later interval whose start is not before I's finish.
+next_compatible(I, J) :-
+  interval(I, _start, Finish, _value),
+  aggregate_min(K, K,
+    (interval(K, Startk, _finishk, _valuek), (K > I), (Startk >= Finish)),
+    J, J).
+next_compatible(I, 9) :-
+  interval(I, _start, Finish, _value),
+  \+ (interval(K, Startk, _finishk, _valuek), (K > I), (Startk >= Finish)).
+
+best_from(9, 0).
+best_from(I, Best) :-
+  last_interval(Last),
+  (I =< Last),
+  (Next is I + 1),
+  best_from(Next, Skip),
+  next_compatible(I, Compatible),
+  best_from(Compatible, Tail),
+  interval(I, _start, _finish, Value),
+  (Take is Value + Tail),
+  (Take >= Skip -> Best = Take ; Best = Skip).
+
+% Reconstruction emits an interval when the take branch matches the optimal value.
+chosen_from(I, I) :-
+  best_from(I, Best),
+  (Next is I + 1),
+  best_from(Next, Skip),
+  next_compatible(I, Compatible),
+  best_from(Compatible, Tail),
+  interval(I, _start, _finish, Value),
+  (Take is Value + Tail),
+  (Best = Take),
+  (Take >= Skip).
+chosen_from(I, Chosen) :-
+  best_from(I, Best),
+  (Next is I + 1),
+  best_from(Next, Skip),
+  next_compatible(I, Compatible),
+  best_from(Compatible, Tail),
+  interval(I, _start, _finish, Value),
+  (Take is Value + Tail),
+  (Best = Take),
+  (Take >= Skip),
+  chosen_from(Compatible, Chosen).
+chosen_from(I, Chosen) :-
+  best_from(I, Best),
+  (Next is I + 1),
+  best_from(Next, Skip),
+  next_compatible(I, Compatible),
+  best_from(Compatible, Tail),
+  interval(I, _start, _finish, Value),
+  (Take is Value + Tail),
+  (Skip > Take),
+  chosen_from(Next, Chosen).
+
+weighted_interval_answer(best_value, Best) :- best_from(1, Best).
+weighted_interval_answer(chosen_interval, interval(I, Start, Finish, Value)) :-
+  chosen_from(1, I),
+  interval(I, Start, Finish, Value).
+weighted_interval_answer(candidate_count, Count) :- countall(interval(_i, _start, _finish, _value), Count).

package/examples/witch.pl

@@ -0,0 +1,43 @@
+% Burn the witch, adapted from Eyeling's examples/witch.n3.
+%
+% This is the classic N3/Semantic Web rule chain in eyeprolog form: a duck
+% floats; something with the same weight as something that floats also floats;
+% things that float are made of wood; things made of wood burn; and a woman
+% who burns is a witch.
+
+% Output declarations: host-supplied goals select the relations written to this example's golden output.
+%% goal: floats(X0)
+
+%% goal: madeOfWood(X0)
+
+%% goal: burns(X0)
+
+%% goal: witch(X0)
+
+%% goal: holds_result(X0, X1)
+
+
+% Program structure: facts set up the scenario, and rules derive the queried conclusions.
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+witch(X) :-
+  burns(X),
+  woman(X).
+
+woman(girl).
+
+burns(X) :-
+  madeOfWood(X).
+
+madeOfWood(X) :-
+  floats(X).
+
+floats(duck).
+
+floats(Y) :-
+  sameWeight(X, Y),
+  floats(X).
+
+sameWeight(duck, girl).
+
+holds_result(witchExample, true) :-
+  witch(girl).

package/examples/wolf-goat-cabbage.pl

@@ -0,0 +1,57 @@
+% Wolf, goat and cabbage puzzle, adapted from Eyelet's
+% input/wolf-goat-cabbage.pl.
+%
+% A configuration is [man, wolf, goat, cabbage], where each item is on the west
+% bank w or east bank e.  The recursive search keeps a visited list so eyeprolog
+% explores the finite state space without looping.
+
+% Output declarations: host-supplied goals select the relations written to this example's golden output.
+%% goal: solution(X0, X1)
+
+%% goal: solved(X0, X1)
+
+
+% Program structure: facts set up the scenario, and rules derive the queried conclusions.
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+solution(Moves) :-
+  solve([w, w, w, w], [e, e, e, e], [[w, w, w, w]], Moves),
+  length(Moves, 7).
+
+solve(Config, Config, _visited, []).
+
+solve(Config, Goal, Visited, [Move|Rest]) :-
+  move(Config, Move, Nextconfig),
+  safe(Nextconfig),
+  \+ member(Nextconfig, Visited),
+  solve(Nextconfig, Goal, [Nextconfig|Visited], Rest).
+
+% Each move transforms one configuration into another.
+move([X, X, Goat, Cabbage], wolf, [Y, Y, Goat, Cabbage]) :-
+  change(X, Y).
+
+move([X, Wolf, X, Cabbage], goat, [Y, Wolf, Y, Cabbage]) :-
+  change(X, Y).
+
+move([X, Wolf, Goat, X], cabbage, [Y, Wolf, Goat, Y]) :-
+  change(X, Y).
+
+move([X, Wolf, Goat, Cabbage], nothing, [Y, Wolf, Goat, Cabbage]) :-
+  change(X, Y).
+
+change(e, w).
+change(w, e).
+
+% Safe if the goat is not left alone with the wolf or cabbage without the man.
+safe([Man, Wolf, Goat, Cabbage]) :-
+  one_eq(Man, Goat, Wolf),
+  one_eq(Man, Goat, Cabbage).
+
+one_eq(X, X, _).
+one_eq(X, _, X).
+
+solution(puzzle, Moves) :-
+  solution(Moves).
+
+solved(puzzle, true) :-
+  solution(_moves).

package/examples/workplace-compliance.pl

@@ -0,0 +1,42 @@
+% Workplace compliance from explicit action facts.
+%
+% The source example generated a large dynamic dataset.  EyeProlog keeps the data
+% explicit and reproducible: each `does/2` fact records an observed employee
+% action, and the rules classify compliant and non-compliant behaviour.
+
+%% goal: status(X0, X1)
+
+
+employee(alice).
+employee(bob).
+employee(carol).
+employee(dave).
+
+does(alice, log_off_at_end_of_shift).
+does(bob, work_related_task).
+does(bob, log_off_at_end_of_shift).
+does(carol, access_social_media).
+does(dave, work_related_task).
+
+% Work-related activity is compliant when the employee also logs off.
+status(Person, compliant) :-
+  employee(Person),
+  does(Person, work_related_task),
+  does(Person, log_off_at_end_of_shift).
+
+% Logging off is compliant by itself when no work task was observed.
+status(Person, compliant) :-
+  employee(Person),
+  does(Person, log_off_at_end_of_shift),
+  \+ does(Person, work_related_task).
+
+% A work task without the required log-off is non-compliant.
+status(Person, non_compliant) :-
+  employee(Person),
+  does(Person, work_related_task),
+  \+ does(Person, log_off_at_end_of_shift).
+
+% Accessing social media is non-compliant in this policy.
+status(Person, non_compliant) :-
+  employee(Person),
+  does(Person, access_social_media).

package/examples/zebra.pl

@@ -0,0 +1,48 @@
+% Zebra puzzle, adapted from Eyelet's input/zebra.pl.
+%
+% Five houses are represented as house(Color, Nationality, Pet, Beverage,
+% Cigarette).  Each clue is a member/2, first/2, third/2, next_to/3, or adjacent/3
+% constraint over that list.  The answer is the classic one: the Norwegian drinks
+% water and the Japanese owns the zebra.
+
+% Output declarations: host-supplied goals select the relations written to this example's golden output.
+%% goal: waterDrinker(X0, X1)
+
+%% goal: zebraOwner(X0, X1)
+
+%% goal: solved(X0, X1)
+
+
+% The single zebra/2 rule is a finite constraint model over the five house slots.
+zebra(Waterdrinker, Zebraowner) :-
+  (Houses = [_, _, _, _, _]),
+  first(Houses, house(_, norwegian, _, _, _)),
+  third(Houses, house(_, _, _, milk, _)),
+  adjacent(house(_, norwegian, _, _, _), house(blue, _, _, _, _), Houses),
+  next_to(house(ivory, _, _, _, _), house(green, _, _, _, _), Houses),
+  member(house(red, english, _, _, _), Houses),
+  member(house(green, _, _, coffee, _), Houses),
+  member(house(yellow, _, _, _, kools), Houses),
+  member(house(_, spanish, dog, _, _), Houses),
+  member(house(_, ukrainian, _, tea, _), Houses),
+  member(house(_, _, snail, _, old_gold), Houses),
+  adjacent(house(_, _, _, _, chesterfields), house(_, _, fox, _, _), Houses),
+  adjacent(house(_, _, _, _, kools), house(_, _, horse, _, _), Houses),
+  member(house(_, _, _, orange_juice, lucky_strike), Houses),
+  member(house(_, japanese, _, _, parliaments), Houses),
+  member(house(_, Waterdrinker, _, water, _), Houses),
+  member(house(_, Zebraowner, zebra, _, _), Houses).
+
+% Positional and neighborhood helpers keep the clue encoding readable.
+first([X|_], X).
+third([_, _, X|_], X).
+
+adjacent(A, B, List) :- next_to(A, B, List).
+adjacent(A, B, List) :- next_to(B, A, List).
+
+next_to(X, Y, [X, Y|_]).
+next_to(X, Y, [_|Zs]) :- next_to(X, Y, Zs).
+
+waterDrinker(zebraPuzzle, Waterdrinker) :- zebra(Waterdrinker, _zebraowner).
+zebraOwner(zebraPuzzle, Zebraowner) :- zebra(_waterdrinker, Zebraowner).
+solved(zebraPuzzle, true) :- zebra(norwegian, japanese).