eyelang 1.2.2 → 1.3.1

package/examples/term-tools.eye

@@ -0,0 +1,32 @@
+% Term-tool builtins for inspecting, constructing, rendering, and validating
+% structured terms.
+%
+% Each report/2 answer demonstrates one meta-programming operation over ordinary
+% Eyelang terms: functor/3 and arg/3 inspect shape, compound_name_arguments/3 can
+% decompose or rebuild a compound, term_string/2 renders a term, and forall/2
+% validates all edge weights.
+%
+% This is a good reference example when writing rules that need to treat terms as
+% data rather than only as predicate calls.
+materialize(report, 2).
+
+edge(a, b, 3).
+edge(b, c, 4).
+
+report(shape, shape(?name, ?arity)) :-
+  functor(edge(a, b, 3), ?name, ?arity).
+
+report(second_argument, ?node) :-
+  arg(2, edge(a, b, 3), ?node).
+
+report(parts, parts(?name, ?args)) :-
+  compound_name_arguments(edge(a, b, 3), ?name, ?args).
+
+report(rebuilt, ?term) :-
+  compound_name_arguments(?term, edge, [c, d, 5]).
+
+report(rendered, ?text) :-
+  term_string(edge(a, [b, c]), ?text).
+
+report(all_weights_positive, yes) :-
+  forall(edge(?_from, ?_to, ?weight), gt(?weight, 0)).

package/examples/totient-summatory.eye

@@ -0,0 +1,33 @@
+% Euler totients and coprimality by tabled Euclidean gcd.
+%
+% phi(N) is modeled directly as the count of integers K in 1..N with gcd(N,K)=1.
+% The summatory query reuses many gcd/totient subgoals, so memoization keeps the
+% example responsive while preserving the relational presentation.
+materialize(totient_answer, 2).
+
+table(gcd, 3).
+table(totient, 2).
+
+% Euclid's algorithm is expressed recursively over remainders.
+gcd(?a, 0, ?a) :- ge(?a, 0).
+gcd(?a, ?b, ?g) :-
+  gt(?b, 0),
+  mod(?a, ?b, ?r),
+  gcd(?b, ?r, ?g).
+
+coprime_upto(?n, ?k) :-
+  between(1, ?n, ?k),
+  gcd(?n, ?k, 1).
+
+% Count the finite coprime generator instead of constructing an explicit list.
+totient(?n, ?count) :-
+  gt(?n, 0),
+  countall(coprime_upto(?n, ?_k), ?count).
+
+summatory_totient(?limit, ?sum) :-
+  sumall(?phi, (between(1, ?limit, ?n), totient(?n, ?phi)), ?sum).
+
+totient_answer(phi_36, ?phi) :- totient(36, ?phi).
+totient_answer(phi_97, ?phi) :- totient(97, ?phi).
+totient_answer(coprime_count_84, ?count) :- totient(84, ?count).
+totient_answer(summatory_phi_30, ?sum) :- summatory_totient(30, ?sum).

package/examples/trust-flow-provenance-threshold.eye

@@ -0,0 +1,47 @@
+% Provenance-derived trust-flow thresholding in Eyelang.
+%
+% Each message combines publisher trust, signature strength, and transform quality
+% into one confidence score.  Receiver-specific thresholds then classify messages
+% as accepted or quarantined and derive status/risk facts.
+%
+% The multiplication chain is intentionally explicit so proof output shows how a
+% provenance trail becomes a single trust decision.
+
+materialize(confidence, 2).
+materialize(trust_flow_state, 2).
+materialize(status, 2).
+materialize(risk, 2).
+
+message(message_a, publisher_a, transform_a, signature_a, receiver_app).
+message(message_b, publisher_b, transform_b, signature_b, receiver_app).
+
+publisher_trust(publisher_a, 0.95).
+publisher_trust(publisher_b, 0.70).
+signature_strength(signature_a, 0.98).
+signature_strength(signature_b, 0.75).
+quality_score(transform_a, 0.96).
+quality_score(transform_b, 0.80).
+acceptance_threshold(receiver_app, 0.85).
+
+confidence(?message, ?confidence) :-
+  message(?message, ?publisher, ?transform, ?signature, ?_receiver),
+  publisher_trust(?publisher, ?publishertrust),
+  signature_strength(?signature, ?signaturetrust),
+  quality_score(?transform, ?quality),
+  mul(?publishertrust, ?signaturetrust, ?a),
+  mul(?a, ?quality, ?confidence).
+
+trust_flow_state(?message, fpv_accepted) :-
+  message(?message, ?_publisher, ?_transform, ?_signature, ?receiver),
+  confidence(?message, ?confidence),
+  acceptance_threshold(?receiver, ?threshold),
+  ge(?confidence, ?threshold).
+
+trust_flow_state(?message, fpv_quarantine) :-
+  message(?message, ?_publisher, ?_transform, ?_signature, ?receiver),
+  confidence(?message, ?confidence),
+  acceptance_threshold(?receiver, ?threshold),
+  lt(?confidence, ?threshold).
+
+status(?message, fpv_high_trust_flow) :- trust_flow_state(?message, fpv_accepted).
+risk(?message, risk_low_trust_data_source) :- trust_flow_state(?message, fpv_quarantine).

package/examples/turing.eye

@@ -0,0 +1,69 @@
+% Universal Turing machine example adapted from Eyelet's input/turing.eye.
+%
+% 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: materialize/2 selects the relations written to this example's golden output.
+materialize(input, 2).
+materialize(output, 2).
+materialize(addsOne, 2).
+
+% 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/vector-similarity.eye

@@ -0,0 +1,60 @@
+% 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 Eyelang lists, so it doubles as a compact
+% demonstration of numeric recursion over list structure.
+
+materialize(dotProduct, 2).
+materialize(normA, 2).
+materialize(normB, 2).
+materialize(cosineSimilarity, 2).
+
+% 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) :-
+  mul(?a, ?b, ?product),
+  dot(?as, ?bs, ?rest),
+  add(?product, ?rest, ?dot).
+
+sum_squares([], 0.0).
+sum_squares([?x|?xs], ?total) :-
+  pow(?x, 2.0, ?squared),
+  sum_squares(?xs, ?rest),
+  add(?squared, ?rest, ?total).
+
+norm(?vector, ?norm) :-
+  sum_squares(?vector, ?sumsquares),
+  pow(?sumsquares, 0.5, ?norm).
+
+% 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),
+  mul(?norma, ?normb, ?denominator),
+  div(?dot, ?denominator, ?similarity).
+
+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.eye

@@ -0,0 +1,69 @@
+% 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.
+
+materialize(uses, 2).
+materialize(impacted_by, 2).
+materialize(risk, 2).
+materialize(mitigate, 2).
+materialize(urgent_patch, 2).
+
+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),
+  gt(?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.eye

@@ -0,0 +1,83 @@
+% Compact web-style terms without full URIs or global prefix tables.
+%
+% RDF-style URIs are globally meaningful but long, while QNames such as
+% schema:Person depend on an external prefix declaration.  This example uses an
+% eyelang-native alternative: web(Space, Local).  The first argument is an
+% ISO-compatible quoted atom naming a vocabulary, organization, or authority;
+% the second argument is the local name inside that space.
+%
+% The important property is that the complete term is self-contained.  The local
+% name josd can safely occur in two spaces: web('be.ugent', josd) and
+% web('com.example', josd) are different Herbrand terms, so there is no hidden
+% prefix context and no accidental collision.  Tooling can still expand selected
+% web/2 terms to full URI strings when a base is known.
+
+materialize(web_uri, 2).
+materialize(affiliated_with, 2).
+materialize(project_contact, 3).
+materialize(same_local_name, 3).
+
+% Optional URI bases for spaces that we want to publish or display.
+space_base('be.ugent', "https://data.ugent.be/id/").
+space_base('com.example', "https://example.com/id/").
+space_base('eyereasoner.github', "https://github.com/eyereasoner/").
+space_base('org.schema', "https://schema.org/").
+
+% A tiny graph using globally scoped web terms as ordinary eyelang terms.
+triple(web('be.ugent', josd), web('org.schema', name), "Jos De Roo").
+triple(web('be.ugent', josd), web('org.schema', email), "josderoo@gmail.com").
+triple(web('be.ugent', josd), web('org.schema', affiliation), web('be.ugent', idlab)).
+triple(web('be.ugent', idlab), web('org.schema', parentOrganization), web('be.ugent', ugent)).
+
+triple(web('eyereasoner.github', eyelang), web('org.schema', name), "eyelang").
+triple(web('eyereasoner.github', eyelang), web('org.schema', codeRepository), "https://github.com/eyereasoner/eyelang").
+triple(web('eyereasoner.github', eyelang), web('org.schema', maintainer), web('be.ugent', josd)).
+
+% Same local spelling, different global identity.
+triple(web('com.example', josd), web('org.schema', name), "Another JosD in another space").
+
+% Keep URI expansion explicit and optional: reasoning uses web/2 terms, while
+% web_uri/2 is only a presentation bridge for selected names.
+published_name(web('be.ugent', josd)).
+published_name(web('com.example', josd)).
+published_name(web('be.ugent', idlab)).
+published_name(web('be.ugent', ugent)).
+published_name(web('eyereasoner.github', eyelang)).
+published_name(web('org.schema', maintainer)).
+
+web_uri(web(?space, ?local), ?uri) :-
+    published_name(web(?space, ?local)),
+    space_base(?space, ?base),
+    atom_string(?local, ?localtext),
+    str_concat(?base, ?localtext, ?uri).
+
+% Organization membership follows parentOrganization links transitively.
+parent_organization(?unit, ?org) :-
+    triple(?unit, web('org.schema', parentOrganization), ?org).
+parent_organization(?unit, ?org) :-
+    triple(?unit, web('org.schema', parentOrganization), ?mid),
+    parent_organization(?mid, ?org).
+
+affiliated_with(?person, ?org) :-
+    triple(?person, web('org.schema', affiliation), ?org).
+affiliated_with(?person, ?org) :-
+    triple(?person, web('org.schema', 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 complete
+% web('be.ugent', josd) term.
+project_contact(?project, ?person, ?email) :-
+    triple(?project, web('org.schema', maintainer), ?person),
+    triple(?person, web('org.schema', email), ?email).
+
+% Demonstrate that local names are not global names.  This reports the deliberate
+% local-name collision without treating the two people as equal.
+local_name(?entity, ?local) :-
+    triple(?entity, web('org.schema', name), ?_),
+    eq(?entity, web(?_, ?local)).
+
+same_local_name(?a, ?b, ?local) :-
+    local_name(?a, ?local),
+    local_name(?b, ?local),
+    lt(?a, ?b).

package/examples/weighted-interval-scheduling.eye

@@ -0,0 +1,81 @@
+% Weighted interval scheduling via 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 tabled decisions to report a schedule.
+materialize(weighted_interval_answer, 2).
+
+table(best_from, 2).
+
+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), gt(?k, ?i), ge(?startk, ?finish)),
+    ?j, ?j).
+next_compatible(?i, 9) :-
+  interval(?i, ?_start, ?finish, ?_value),
+  not((interval(?k, ?startk, ?_finishk, ?_valuek), gt(?k, ?i), ge(?startk, ?finish))).
+
+best_from(9, 0).
+best_from(?i, ?best) :-
+  last_interval(?last),
+  le(?i, ?last),
+  add(?i, 1, ?next),
+  best_from(?next, ?skip),
+  next_compatible(?i, ?compatible),
+  best_from(?compatible, ?tail),
+  interval(?i, ?_start, ?_finish, ?value),
+  add(?value, ?tail, ?take),
+  max(?take, ?skip, ?best).
+
+% Reconstruction emits an interval when the take branch matches the optimal value.
+chosen_from(?i, ?i) :-
+  best_from(?i, ?best),
+  add(?i, 1, ?next),
+  best_from(?next, ?skip),
+  next_compatible(?i, ?compatible),
+  best_from(?compatible, ?tail),
+  interval(?i, ?_start, ?_finish, ?value),
+  add(?value, ?tail, ?take),
+  eq(?best, ?take),
+  ge(?take, ?skip).
+chosen_from(?i, ?chosen) :-
+  best_from(?i, ?best),
+  add(?i, 1, ?next),
+  best_from(?next, ?skip),
+  next_compatible(?i, ?compatible),
+  best_from(?compatible, ?tail),
+  interval(?i, ?_start, ?_finish, ?value),
+  add(?value, ?tail, ?take),
+  eq(?best, ?take),
+  ge(?take, ?skip),
+  chosen_from(?compatible, ?chosen).
+chosen_from(?i, ?chosen) :-
+  best_from(?i, ?best),
+  add(?i, 1, ?next),
+  best_from(?next, ?skip),
+  next_compatible(?i, ?compatible),
+  best_from(?compatible, ?tail),
+  interval(?i, ?_start, ?_finish, ?value),
+  add(?value, ?tail, ?take),
+  gt(?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.eye

@@ -0,0 +1,38 @@
+% Burn the witch, adapted from Eyeling's examples/witch.n3.
+%
+% This is the classic N3/Semantic Web rule chain in eyelang 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: materialize/2 selects the relations written to this example's golden output.
+materialize(floats, 1).
+materialize(madeOfWood, 1).
+materialize(burns, 1).
+materialize(witch, 1).
+materialize(is, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized 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).
+
+is(witchExample, true) :-
+  witch(girl).

package/examples/wolf-goat-cabbage.eye

@@ -0,0 +1,56 @@
+% Wolf, goat and cabbage puzzle, adapted from Eyelet's
+% input/wolf-goat-cabbage.eye.
+%
+% 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 eyelang
+% explores the finite state space without looping.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(solution, 2).
+materialize(solved, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+table(solve, 4).
+
+% 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),
+  not_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/zebra.eye

@@ -0,0 +1,45 @@
+% Zebra puzzle, adapted from Eyelet's input/zebra.eye.
+%
+% 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: materialize/2 selects the relations written to this example's golden output.
+materialize(waterDrinker, 2).
+materialize(zebraOwner, 2).
+materialize(solved, 2).
+
+% The single zebra/2 rule is a finite constraint model over the five house slots.
+zebra(?waterdrinker, ?zebraowner) :-
+  eq(?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).

package/index.d.ts

@@ -39,7 +39,7 @@ export interface EyelangPredicateGroup {
   clauses: EyelangClause[];
   argIndexes: unknown[];
   pairIndexes: unknown[];
-  memoized: boolean;
+  tabled: boolean;
   recursive: boolean;
 }
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "eyelang",
-  "version": "1.2.2",
-  "description": "A small Prolog-syntax-subset logic programming language for rules, goals, answers, and proofs.",
+  "version": "1.3.1",
+  "description": "A small Prolog-like logic programming language for rules, goals, answers, and proofs.",
   "type": "module",
   "main": "./index.js",
   "types": "./index.d.ts",