eyeling 1.34.5 → 2.34.7

package/examples/eyelang/socket-age.pl

@@ -1,39 +0,0 @@
-% socket-age.pl
-%
-% A small runnable eyelang Socket example for age reasoning.
-%
-% The socket facts are ordinary eyelang data. They document the semantic
-% openings that this rule module expects:
-%
-%   - a patient registry that provides birthDay/2
-%   - a policy source that provides duration/2
-%   - a clock source that provides today/1
-%
-% The plug facts say which concrete providers are connected.
-%
-% Run:
-%   eyelang socket-age.pl
-
-% Output declarations: materialize/2 selects the relations written to this example's golden output.
-materialize(ageAbove, 2).
-
-% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
-socket(patient_registry, provides(birthDay_2)).
-socket(policy_source, provides(duration_2)).
-socket(clock_source, provides(today_1)).
-
-plug(test_patients, patient_registry).
-plug(test_policy, policy_source).
-plug(test_clock, clock_source).
-
-birthDay(patH, "1944-08-21").
-duration(check, "P80Y").
-today("2026-05-30").
-
-% Derivation rules: each rule below contributes one logical step toward the displayed results.
-ageAbove(S, A) :-
-    birthDay(S, B),
-    duration(check, A),
-    today(D),
-    difference(D, B, F),
-    gt(F, A).

package/examples/eyelang/socket-family.pl

@@ -1,28 +0,0 @@
-% socket-family.pl
-%
-% A small runnable eyelang Socket example.
-%
-% The socket facts below are ordinary eyelang data. They document the
-% semantic opening: this reasoning module expects a provider for parent/2.
-% The plug fact says which provider is connected.
-%
-% Run:
-%   eyelang socket-family.pl
-
-% Output declarations: materialize/2 selects the relations written to this example's golden output.
-materialize(ancestor, 2).
-
-% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
-socket(family_source, provides(parent_2)).
-plug(family_file, family_source).
-
-parent(pat, jan).
-parent(jan, emma).
-
-% Derivation rules: each rule below contributes one logical step toward the displayed results.
-ancestor(X, Y) :-
-    parent(X, Y).
-
-ancestor(X, Z) :-
-    parent(X, Y),
-    ancestor(Y, Z).

package/examples/eyelang/socrates.pl

@@ -1,19 +0,0 @@
-% Socrates is mortal, adapted from Eyelet's input/socrates.pl.
-%
-% Eyelet uses type('Socrates', 'Man') and a single rule deriving Mortal.
-% eyelang keeps the same reasoning shape and emits relation facts.
-
-% Output declarations: materialize/2 selects the relations written to this example's golden output.
-materialize(type, 2).
-materialize(is, 2).
-
-% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
-type(socrates, man).
-
-% Derivation rules: each rule below contributes one logical step toward the displayed results.
-type(X, mortal) :-
-  type(X, man).
-
-
-is(test, true) :-
-  type(socrates, mortal).

package/examples/eyelang/statistics-summary.pl

@@ -1,54 +0,0 @@
-% Population statistics for a small numeric sample.
-%
-% The sample is the textbook data set [2,4,4,4,5,5,7,9], whose population
-% mean is 5, variance is 4, and standard deviation is 2.
-
-% Output declarations: materialize/2 selects the relations written to this example's golden output.
-materialize(count, 2).
-materialize(mean, 2).
-materialize(populationVariance, 2).
-materialize(populationStddev, 2).
-
-% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
-sample(scores, [2.0, 4.0, 4.0, 4.0, 5.0, 5.0, 7.0, 9.0]).
-
-sum([], 0.0).
-% Derivation rules: each rule below contributes one logical step toward the displayed results.
-sum([X|Xs], Total) :-
-  sum(Xs, Rest),
-  add(X, Rest, Total).
-
-mean(Name, Mean) :-
-  sample(Name, Values),
-  sum(Values, Total),
-  length(Values, Count),
-  div(Total, Count, Mean).
-
-squared_error_sum([], _Mean, 0.0).
-squared_error_sum([X|Xs], Mean, Total) :-
-  sub(X, Mean, Delta),
-  pow(Delta, 2.0, Squared),
-  squared_error_sum(Xs, Mean, Rest),
-  add(Squared, Rest, Total).
-
-population_variance(Name, Variance) :-
-  sample(Name, Values),
-  mean(Name, Mean),
-  squared_error_sum(Values, Mean, SumSquaredErrors),
-  length(Values, Count),
-  div(SumSquaredErrors, Count, Variance).
-
-population_stddev(Name, Stddev) :-
-  population_variance(Name, Variance),
-  pow(Variance, 0.5, Stddev).
-
-count(Name, Count) :-
-  sample(Name, Values),
-  length(Values, Count).
-
-
-populationVariance(Name, Variance) :-
-  population_variance(Name, Variance).
-
-populationStddev(Name, Stddev) :-
-  population_stddev(Name, Stddev).

package/examples/eyelang/superdense-coding.pl

@@ -1,84 +0,0 @@
-% Superdense coding using discrete quantum computing, adapted from
-% Eyelet's input/superdense-coding.pl.
-%
-% The Eyelet program toggles dynamic sdcoding/2 facts so answers appearing an
-% even number of times cancel. eyelang expresses the same finite example
-% declaratively: for this protocol the surviving messages are exactly those
-% with a single support path after the interference choices are expanded.
-
-% |R) = |0, 0) + |1, 1)
-% Output declarations: materialize/2 selects the relations written to this example's golden output.
-materialize(decodesAs, 2).
-materialize(preservesMessage, 2).
-materialize(cancelsCrossTalk, 2).
-
-% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
-r(false, false).
-r(true, true).
-
-% ID |0) = |0), ID |1) = |1)
-identity(false, false).
-identity(true, true).
-
-% G |0) = |1), G |1) = |0)
-g(false, true).
-g(true, false).
-
-% K |0) = |0), K |1) = |0) + |1)
-k(false, false).
-k(true, false).
-k(true, true).
-
-% KG and GK compositions.
-% Derivation rules: each rule below contributes one logical step toward the displayed results.
-kg(X, Y) :-
-  g(X, Z),
-  k(Z, Y).
-
-gk(X, Y) :-
-  k(X, Z),
-  g(Z, Y).
-
-% Alice encodes two classical bits as one of four transformations.
-alice(0, X, Y) :- identity(X, Y).
-alice(1, X, Y) :- g(X, Y).
-alice(2, X, Y) :- k(X, Y).
-alice(3, X, Y) :- kg(X, Y).
-
-% Bob decodes with the Bell-style measurement basis.
-bob(X, Y, 0) :- gk(X, Y).
-bob(X, Y, 1) :- k(X, Y).
-bob(X, Y, 2) :- g(X, Y).
-bob(X, Y, 3) :- identity(X, Y).
-
-% One concrete support path through the entangled pair and the two transforms.
-sdc_path(N, M, path(X, Y, B)) :-
-  r(X, Y),
-  alice(N, X, B),
-  bob(B, Y, M).
-
-% If another different support path gives the same answer, this answer cancels
-% in pairs in the finite superdense-coding table.
-duplicate_sdc_path(N, M, Proof) :-
-  sdc_path(N, M, Proof),
-  sdc_path(N, M, Other),
-  neq(Proof, Other).
-
-sdcoding(N, M) :-
-  sdc_path(N, M, Proof),
-  not(duplicate_sdc_path(N, M, Proof)).
-
-decodesAs(message(N), M) :-
-  sdcoding(N, M).
-
-preservesMessage(protocol, true) :-
-  sdcoding(0, 0),
-  sdcoding(1, 1),
-  sdcoding(2, 2),
-  sdcoding(3, 3).
-
-cancelsCrossTalk(protocol, true) :-
-  not(sdcoding(0, 1)),
-  not(sdcoding(1, 0)),
-  not(sdcoding(2, 3)),
-  not(sdcoding(3, 2)).

package/examples/eyelang/term-tools.pl

@@ -1,23 +0,0 @@
-% Term tools: inspect and build structured terms, then validate all facts with forall/2.
-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/eyelang/trust-flow-provenance-threshold.pl

@@ -1,40 +0,0 @@
-% Provenance-derived trust-flow thresholding in eyelang.
-
-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/eyelang/turing.pl

@@ -1,67 +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.
-% 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).
-
-% 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.
-compute([], OutTape) :-
-  start(_Machine, I),
-  find(I, [], #, [], OutTape).
-
-compute([Head|Tail], OutTape) :-
-  start(_Machine, I),
-  find(I, [], Head, Tail, OutTape).
-
-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).
-
-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/eyelang/vector-similarity.pl

@@ -1,56 +0,0 @@
-% Vector dot product, Euclidean norm, and cosine similarity.
-
-% Output declarations: materialize/2 selects the relations written to this example's golden output.
-materialize(dotProduct, 2).
-materialize(normA, 2).
-materialize(normB, 2).
-materialize(cosineSimilarity, 2).
-
-% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
-% 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).
-% Derivation rules: each rule below contributes one logical step toward the displayed results.
-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/eyelang/vulnerability-impact.pl

@@ -1,70 +0,0 @@
-% Vulnerability impact analysis over a transitive dependency graph.
-%
-% This mirrors examples/vulnerability-impact.n3 using eyelang rules.
-
-% Output declarations: materialize/2 selects the relations written to this example's golden output.
-materialize(uses, 2).
-materialize(impacted_by, 2).
-materialize(risk, 2).
-materialize(mitigate, 2).
-materialize(urgent_patch, 2).
-
-% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
-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).
-
-% Derivation rules: each rule below contributes one logical step toward the displayed results.
-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(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/eyelang/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/eyelang/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/eyelang/zebra.pl

@@ -1,44 +0,0 @@
-% Zebra puzzle, adapted from Eyelet's input/zebra.pl.
-%
-% Five houses are represented as house(Color, Nationality, Pet, Beverage,
-% Cigarette).  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).
-
-% 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.
-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).
-
-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).