eyelang 1.2.1 → 1.3.0

package/examples/term-tools.pl

@@ -1,32 +0,0 @@
-% 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.pl

@@ -1,33 +0,0 @@
-% Euler totients and coprimality by memoized 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).
-
-memoize(gcd, 3).
-memoize(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.pl

@@ -1,47 +0,0 @@
-% 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.pl

@@ -1,69 +0,0 @@
-% 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: 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.pl

@@ -1,60 +0,0 @@
-% 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.pl

@@ -1,69 +0,0 @@
-% 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.pl

@@ -1,83 +0,0 @@
-% 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 a dotted
-% atom that names 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 names 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.pl

@@ -1,81 +0,0 @@
-% Weighted interval scheduling via memoized 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 memoized decisions to report a schedule.
-materialize(weighted_interval_answer, 2).
-
-memoize(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.pl

@@ -1,38 +0,0 @@
-% 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.pl

@@ -1,56 +0,0 @@
-% 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 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.
-memoize(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.pl

@@ -1,45 +0,0 @@
-% 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: 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/test/conformance/cases/001_fact_output.pl

@@ -1,4 +0,0 @@
-% Reference 6, 7, 11: facts can be exposed through a materialized derived predicate.
-materialize(parent, 2).
-base_parent(pat, jan).
-parent(X, Y) :- base_parent(X, Y).

package/test/conformance/cases/002_rule_recursion.pl

@@ -1,7 +0,0 @@
-% Reference 6, 7: definite clauses, conjunction, and recursive proof search.
-materialize(ancestor, 2).
-parent(pat, jan).
-parent(jan, emma).
-ancestor_any(X, Y) :- parent(X, Y).
-ancestor_any(X, Z) :- parent(X, Y), ancestor_any(Y, Z).
-ancestor(pat, Y) :- ancestor_any(pat, Y).

package/test/conformance/cases/003_terms_and_readback.pl

@@ -1,16 +0,0 @@
-% Reference 3, 5, 11: scalars, compounds, lists, and read-back printing.
-materialize(value, 2).
-raw_value(atom, pat).
-raw_value(quoted_atom, 'atom with spaces').
-raw_value(quoted_quote, 'needs''quote').
-raw_value(empty_atom, '').
-raw_value(string, "line\nquote: \"ok\"").
-raw_value(integer, -42).
-raw_value(decimal, 0.25).
-raw_value(scientific, 1.25e-3).
-raw_value(compound, pair(3, nested(atom, [x, y]))).
-raw_value(arity_zero_atom, nil).
-raw_value(empty_list, []).
-raw_value(proper_list, [a, b, c]).
-raw_value(improper_list, [a, b | tail]).
-value(K, V) :- raw_value(K, V).

package/test/conformance/cases/004_conjunction_and_parentheses.pl

@@ -1,5 +0,0 @@
-% Reference 5.5, 7: parenthesized comma terms are conjunctions in goal position.
-p(a).
-q(a).
-ok(X, yes) :- (p(X), q(X)).
-materialize(ok, 2).

package/test/conformance/cases/005_list_deconstruction.pl

@@ -1,6 +0,0 @@
-% Reference 5.4, 12.1: list syntax and unification in rule heads.
-first([X | _Rest], X).
-tail([_Head | Tail], Tail).
-answer(first, X) :- first([a, b, c], X).
-answer(tail, Tail) :- tail([a, b, c], Tail).
-materialize(answer, 2).

package/test/conformance/cases/006_comma_formula_data.pl

@@ -1,4 +0,0 @@
-% Reference 5.5: comma terms remain data outside goal position.
-record((name(alice, "Alice"), knows(alice, bob))).
-answer(formula, F) :- record(F).
-materialize(answer, 2).

package/test/conformance/cases/007_anonymous_variables.pl

@@ -1,5 +0,0 @@
-% Reference 3.4, 5.1, 7.1: each anonymous variable occurrence is fresh.
-pair(a, one).
-pair(b, two).
-answer(fresh, yes) :- pair(a, _), pair(b, _).
-materialize(answer, 2).