eyeling 1.32.0 → 1.33.0

package/examples/eyelang/group-inverse-uniqueness.pl

@@ -0,0 +1,34 @@
+% 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: materialize/2 selects the relations written to this example's golden output.
+materialize(sameInverse, 3).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+element(e).
+element(x).
+element(i).
+element(j).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+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),
+  neq(B, C).

package/examples/eyelang/hamiltonian-cycle.pl

@@ -0,0 +1,55 @@
+% Hamiltonian cycle without cut.
+%
+% The graph has eight vertices and enough chords to create a non-trivial search
+% space.  The first vertex is fixed to avoid rotational duplicates; the two
+% cycle directions are still distinct, so the count is for cycles from a fixed
+% start in traversal order.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(status, 2).
+materialize(witness, 2).
+materialize(vertexCount, 2).
+materialize(cycleCountFromA, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+edge(a, b).
+edge(a, f).
+edge(a, g).
+edge(a, h).
+edge(b, c).
+edge(b, d).
+edge(b, g).
+edge(b, h).
+edge(c, d).
+edge(c, e).
+edge(c, g).
+edge(d, e).
+edge(d, g).
+edge(d, h).
+edge(e, f).
+edge(f, g).
+edge(g, h).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+adjacent(X, Y) :- edge(X, Y).
+adjacent(X, Y) :- edge(Y, X).
+
+vertices([a, b, c, d, e, f, g, h]).
+
+hamiltonian_cycle(Cycle) :-
+  vertices(Vertices),
+  hamiltonian_cycle(edge, Vertices, Cycle).
+
+status(hamiltonian_cycle, exists) :-
+  once(hamiltonian_cycle(_Cycle)).
+
+witness(hamiltonian_cycle, Cycle) :-
+  once(hamiltonian_cycle(Cycle)).
+
+vertexCount(hamiltonian_cycle, Count) :-
+  vertices(Vertices),
+  length(Vertices, Count).
+
+cycleCountFromA(hamiltonian_cycle, Count) :-
+  findall(Cycle, hamiltonian_cycle(Cycle), Cycles),
+  length(Cycles, Count).

package/examples/eyelang/hamiltonian-path.pl

@@ -0,0 +1,49 @@
+% Hamiltonian path, adapted from Eyelet's input/hamiltonian-path.pl.
+%
+% The graph is the same six-vertex undirected graph.  eyelang spells the finite
+% vertex set directly and derives every path that visits each vertex exactly
+% once.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(hasHamiltonianPath, 2).
+materialize(hamiltonianPath, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+memoize(adjacent, 2).
+
+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).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+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), not_member(B, [A]),
+  vertex(C), adjacent(B, C), not_member(C, [A, B]),
+  vertex(D), adjacent(C, D), not_member(D, [A, B, C]),
+  vertex(E), adjacent(D, E), not_member(E, [A, B, C, D]),
+  vertex(F), adjacent(E, F), not_member(F, [A, B, C, D, E]).
+
+hasHamiltonianPath(graph, true) :-
+  hamiltonian_path(_Path).
+
+hamiltonianPath(graph, Path) :-
+  hamiltonian_path(Path).

package/examples/eyelang/hamming-code.pl

@@ -0,0 +1,105 @@
+% Technology example: Hamming(7,4) single-bit error correction.
+%
+% The received word has one corrupted bit. Syndrome bits identify the bad
+% position, then the corrected codeword and decoded payload are derived.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(syndrome, 2).
+materialize(errorBit, 2).
+materialize(correctedCodeword, 2).
+materialize(decodedPayload, 2).
+materialize(status, 2).
+materialize(reason, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+received_bit(packet1, 1, 1).
+received_bit(packet1, 2, 0).
+received_bit(packet1, 3, 1).
+received_bit(packet1, 4, 1).
+received_bit(packet1, 5, 1).
+received_bit(packet1, 6, 1).
+received_bit(packet1, 7, 0).
+
+flip(0, 1).
+flip(1, 0).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+parity4(A, B, C, D, Parity) :-
+  add(A, B, AB),
+  add(AB, C, ABC),
+  add(ABC, D, Sum),
+  mod(Sum, 2, Parity).
+
+syndrome_bit1(Code, S1) :-
+  received_bit(Code, 1, B1),
+  received_bit(Code, 3, B3),
+  received_bit(Code, 5, B5),
+  received_bit(Code, 7, B7),
+  parity4(B1, B3, B5, B7, S1).
+
+syndrome_bit2(Code, S2) :-
+  received_bit(Code, 2, B2),
+  received_bit(Code, 3, B3),
+  received_bit(Code, 6, B6),
+  received_bit(Code, 7, B7),
+  parity4(B2, B3, B6, B7, S2).
+
+syndrome_bit4(Code, S4) :-
+  received_bit(Code, 4, B4),
+  received_bit(Code, 5, B5),
+  received_bit(Code, 6, B6),
+  received_bit(Code, 7, B7),
+  parity4(B4, B5, B6, B7, S4).
+
+syndrome(Code, Syndrome) :-
+  syndrome_bit1(Code, S1),
+  syndrome_bit2(Code, S2),
+  syndrome_bit4(Code, S4),
+  mul(S2, 2, WeightedS2),
+  mul(S4, 4, WeightedS4),
+  add(S1, WeightedS2, Partial),
+  add(Partial, WeightedS4, Syndrome).
+
+corrected_bit(Code, Position, Corrected) :-
+  syndrome(Code, Position),
+  received_bit(Code, Position, Bit),
+  flip(Bit, Corrected).
+
+corrected_bit(Code, Position, Bit) :-
+  syndrome(Code, ErrorPosition),
+  neq(Position, ErrorPosition),
+  received_bit(Code, Position, Bit).
+
+corrected_codeword(Code, [B1, B2, B3, B4, B5, B6, B7]) :-
+  corrected_bit(Code, 1, B1),
+  corrected_bit(Code, 2, B2),
+  corrected_bit(Code, 3, B3),
+  corrected_bit(Code, 4, B4),
+  corrected_bit(Code, 5, B5),
+  corrected_bit(Code, 6, B6),
+  corrected_bit(Code, 7, B7).
+
+decoded_payload(Code, [D1, D2, D3, D4]) :-
+  corrected_bit(Code, 3, D1),
+  corrected_bit(Code, 5, D2),
+  corrected_bit(Code, 6, D3),
+  corrected_bit(Code, 7, D4).
+
+
+errorBit(Code, Position) :-
+  syndrome(Code, Position),
+  gt(Position, 0).
+
+correctedCodeword(Code, Codeword) :-
+  corrected_codeword(Code, Codeword).
+
+decodedPayload(Code, Payload) :-
+  decoded_payload(Code, Payload).
+
+status(Code, single_bit_corrected) :-
+  syndrome(Code, Position),
+  gt(Position, 0).
+
+reason(Code, "Hamming syndrome identifies the flipped bit position") :-
+  syndrome(Code, Position),
+  gt(Position, 0).

package/examples/eyelang/hanoi.pl

@@ -0,0 +1,20 @@
+% Towers of Hanoi adapted from Eyeling hanoi.n3.
+% Output is the complete list of moves for size 3.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(answer, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+memoize(hanoi, 5).
+
+hanoi(0, _From, _To, _Via, []).
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+hanoi(N, From, To, Via, Moves) :-
+  gt(N, 0),
+  sub(N, 1, N1),
+  hanoi(N1, From, Via, To, Before),
+  hanoi(N1, Via, To, From, After),
+  append(Before, [[From, To]|After], Moves).
+
+answer(3, Moves) :-
+  hanoi(3, left, right, center, Moves).

package/examples/eyelang/heat-loss.pl

@@ -0,0 +1,51 @@
+% Engineering example: one-dimensional conductive heat loss through a wall.
+%
+% Thermal resistance is L/(k*A), and heat loss is DeltaT/R.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(type, 2).
+materialize(temperatureDifference_K, 2).
+materialize(thermalResistance_K_W, 2).
+materialize(heatLoss_W, 2).
+materialize(status, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+wall(wall1, conductivity_W_mK, 0.8).
+wall(wall1, area_m2, 12.0).
+wall(wall1, thickness_m, 0.2).
+wall(wall1, indoor_C, 21.0).
+wall(wall1, outdoor_C, -4.0).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+temperature_difference(Wall, DeltaT) :-
+  wall(Wall, indoor_C, Indoor),
+  wall(Wall, outdoor_C, Outdoor),
+  sub(Indoor, Outdoor, DeltaT).
+
+thermal_resistance(Wall, Resistance) :-
+  wall(Wall, thickness_m, Thickness),
+  wall(Wall, conductivity_W_mK, Conductivity),
+  wall(Wall, area_m2, Area),
+  mul(Conductivity, Area, Conductance),
+  div(Thickness, Conductance, Resistance).
+
+heat_loss(Wall, HeatLoss) :-
+  temperature_difference(Wall, DeltaT),
+  thermal_resistance(Wall, Resistance),
+  div(DeltaT, Resistance, HeatLoss).
+
+type(Wall, conduction_heat_loss) :-
+  wall(Wall, thickness_m, _Thickness).
+
+temperatureDifference_K(Wall, DeltaT) :-
+  temperature_difference(Wall, DeltaT).
+
+thermalResistance_K_W(Wall, Resistance) :-
+  thermal_resistance(Wall, Resistance).
+
+heatLoss_W(Wall, HeatLoss) :-
+  heat_loss(Wall, HeatLoss).
+
+status(Wall, high_heat_loss) :-
+  heat_loss(Wall, HeatLoss),
+  gt(HeatLoss, 1000.0).

package/examples/eyelang/heron-theorem.pl

@@ -0,0 +1,36 @@
+% Heron's theorem: area = sqrt(s(s-a)(s-b)(s-c)).
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(semiperimeter, 2).
+materialize(heronProduct, 2).
+materialize(area, 2).
+materialize(status, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+% 13-14-15 is a classic integer-sided triangle with area 84.
+triangle(field_plot, 13, 14, 15).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+semiperimeter(Triangle, S) :-
+  triangle(Triangle, A, B, C),
+  add(A, B, AB),
+  add(AB, C, Sum),
+  div(Sum, 2, S).
+
+% Area is obtained by taking the square root of this Heron product.
+heron_product(Triangle, Product) :-
+  triangle(Triangle, A, B, C),
+  semiperimeter(Triangle, S),
+  sub(S, A, SA),
+  sub(S, B, SB),
+  sub(S, C, SC),
+  mul(S, SA, T1),
+  mul(T1, SB, T2),
+  mul(T2, SC, Product).
+
+area(Triangle, Area) :-
+  heron_product(Triangle, Product),
+  pow(Product, 0.5, Area).
+
+heronProduct(Triangle, P) :- heron_product(Triangle, P).
+status(Triangle, valid_survey_triangle) :- area(Triangle, A), gt(A, 0).

package/examples/eyelang/ideal-gas-law.pl

@@ -0,0 +1,37 @@
+% Science example: ideal gas law.
+%
+% A simple gas cell uses P*V = n*R*T.  The constants are chosen so that the
+% computed pressure is exactly near one atmosphere in this small example.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(pressure_Pa, 2).
+materialize(status, 2).
+materialize(reason, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+gas_cell(cell1, 1.0, 8.0, 300.0, 0.024).
+pressure_limit(cell1, low_Pa, 95000.0).
+pressure_limit(cell1, high_Pa, 105000.0).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+pressure(Cell, Pressure) :-
+  gas_cell(Cell, Moles, GasConstant, Temperature, Volume),
+  mul(Moles, GasConstant, NR),
+  mul(NR, Temperature, NRT),
+  div(NRT, Volume, Pressure).
+
+near_atmospheric(Cell) :-
+  pressure(Cell, Pressure),
+  pressure_limit(Cell, low_Pa, Low),
+  pressure_limit(Cell, high_Pa, High),
+  gt(Pressure, Low),
+  lt(Pressure, High).
+
+pressure_Pa(Cell, Pressure) :-
+  pressure(Cell, Pressure).
+
+status(Cell, near_atmospheric) :-
+  near_atmospheric(Cell).
+
+reason(Cell, "pressure is inside the one-atmosphere tolerance band") :-
+  near_atmospheric(Cell).

package/examples/eyelang/illegitimate-reasoning.pl

@@ -0,0 +1,88 @@
+% Illegitimate reasoning detector.
+%
+% The input facts describe arguments and their surface reasoning pattern. Helper
+% predicates identify common invalid inference forms. The output layer emits only
+% concise report relations: the argument is illegitimate, which fallacy was found,
+% the challenged conclusion, and a short reason why.
+
+% Affirming the consequent:
+%   If it rained, the street is wet. The street is wet. Therefore it rained.
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(type, 2).
+materialize(fallacy, 2).
+materialize(conclusion, 2).
+materialize(reason, 2).
+materialize(sampleSize, 2).
+materialize(requiredSampleSize, 2).
+materialize(omittedAlternative, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+argument(arg_affirming_consequent).
+implication(arg_affirming_consequent, rain, street_wet).
+observed(arg_affirming_consequent, street_wet).
+concludes(arg_affirming_consequent, rain).
+
+% Denying the antecedent:
+%   If the key is present, the door opens. The key is not present. Therefore the door does not open.
+argument(arg_denying_antecedent).
+implication(arg_denying_antecedent, key_present, door_opens).
+observed(arg_denying_antecedent, neg(key_present)).
+concludes(arg_denying_antecedent, neg(door_opens)).
+
+% Hasty generalization:
+%   Three sampled cases are treated as enough for a universal conclusion.
+argument(arg_hasty_generalization).
+sample_size(arg_hasty_generalization, 3).
+required_sample_size(arg_hasty_generalization, 30).
+concludes(arg_hasty_generalization, all(crows, black)).
+
+% False dilemma:
+%   Only two choices are presented even though a relevant third option exists.
+argument(arg_false_dilemma).
+presented_alternatives(arg_false_dilemma, [approve_now, reject_forever]).
+omitted_alternative(arg_false_dilemma, revise_proposal).
+concludes(arg_false_dilemma, approve_now).
+
+% A contrast case: modus ponens is not flagged.
+argument(arg_modus_ponens).
+implication(arg_modus_ponens, subscription_paid, access_allowed).
+observed(arg_modus_ponens, subscription_paid).
+concludes(arg_modus_ponens, access_allowed).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+fallacy(A, affirming_consequent) :-
+  argument(A),
+  implication(A, Antecedent, Consequent),
+  observed(A, Consequent),
+  concludes(A, Antecedent).
+
+fallacy(A, denying_antecedent) :-
+  argument(A),
+  implication(A, Antecedent, Consequent),
+  observed(A, neg(Antecedent)),
+  concludes(A, neg(Consequent)).
+
+fallacy(A, hasty_generalization) :-
+  argument(A),
+  sample_size(A, N),
+  required_sample_size(A, Min),
+  lt(N, Min),
+  concludes(A, all(_, _)).
+
+fallacy(A, false_dilemma) :-
+  argument(A),
+  presented_alternatives(A, _),
+  omitted_alternative(A, _),
+  concludes(A, _).
+
+reason(arg_affirming_consequent, "observing the consequent does not prove the antecedent").
+reason(arg_denying_antecedent, "denying the antecedent does not disprove the consequent").
+reason(arg_hasty_generalization, "sample size is below the threshold for a universal conclusion").
+reason(arg_false_dilemma, "a relevant alternative is omitted").
+
+type(A, illegitimate_reasoning) :- fallacy(A, _).
+conclusion(A, C) :- fallacy(A, _), concludes(A, C).
+reason(A, R) :- fallacy(A, _), reason(A, R).
+sampleSize(A, N) :- fallacy(A, hasty_generalization), sample_size(A, N).
+requiredSampleSize(A, Min) :- fallacy(A, hasty_generalization), required_sample_size(A, Min).
+omittedAlternative(A, Alt) :- fallacy(A, false_dilemma), omitted_alternative(A, Alt).

package/examples/eyelang/kaprekar.pl

@@ -0,0 +1,32 @@
+% Kaprekar's constant demo, adapted from Eyelet's input/kaprekar.pl.
+%
+% This is deliberately a rule-level example, not a native builtin.  It extracts
+% four digits, sorts them, subtracts ascending from descending, and recurses
+% until Kaprekar's constant 6174 is reached.  The sample set is small so the
+% example remains a millisecond-scale demo in the normal test suite.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(constant, 2).
+materialize(kaprekarSteps, 2).
+materialize(reachesConstant, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+memoize(kaprekar, 3).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+recursion_count(N, Count) :-
+  kaprekar_steps(N, Count).
+
+sample(3524).
+sample(2111).
+sample(9831).
+sample(6174).
+constant(kaprekar, 6174).
+
+kaprekarSteps(N, Count) :-
+  sample(N),
+  recursion_count(N, Count).
+
+reachesConstant(kaprekar, N) :-
+  sample(N),
+  recursion_count(N, _Count).

package/examples/eyelang/law-of-cosines.pl

@@ -0,0 +1,31 @@
+% Law of cosines: c^2 = a^2 + b^2 - 2ab cos(C).
+% The example uses a 60-degree included angle, so cos(C) is represented as 0.5.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(sideCSquared, 2).
+materialize(sideC, 2).
+materialize(status, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+% Stored tuple is triangle(Name, sideA, sideB, cosIncludedAngle).
+triangle(tri60, 7, 9, 0.5).
+
+% Compute c^2 first so both squared and square-rooted outputs can be shown.
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+side_c_squared(Triangle, C2) :-
+  triangle(Triangle, A, B, CosC),
+  mul(A, A, A2),
+  mul(B, B, B2),
+  add(A2, B2, Sum),
+  mul(2, A, TwoA),
+  mul(TwoA, B, TwoAB),
+  mul(TwoAB, CosC, Projection),
+  sub(Sum, Projection, C2).
+
+side_c(Triangle, C) :-
+  side_c_squared(Triangle, C2),
+  pow(C2, 0.5, C).
+
+sideCSquared(Triangle, C2) :- side_c_squared(Triangle, C2).
+sideC(Triangle, C) :- side_c(Triangle, C).
+status(Triangle, acute_triangle) :- side_c_squared(Triangle, C2), gt(C2, 0).

package/examples/eyelang/least-squares-regression.pl

@@ -0,0 +1,81 @@
+% Math example: least-squares linear regression.
+%
+% The rules reduce a list of points to sufficient statistics, then derive the
+% fitted slope, intercept, and coefficient of determination R^2.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(slope, 2).
+materialize(intercept, 2).
+materialize(rSquared, 2).
+materialize(status, 2).
+materialize(reason, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+dataset(regression1, [point(1.0, 2.0), point(2.0, 3.0), point(3.0, 5.0), point(4.0, 4.0)]).
+threshold(regression1, minimum_r_squared, 0.60).
+
+stats([], 0.0, 0.0, 0.0, 0.0, 0.0, 0.0).
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+stats([point(X, Y)|Rest], N, SumX, SumY, SumXX, SumXY, SumYY) :-
+  stats(Rest, N0, SumX0, SumY0, SumXX0, SumXY0, SumYY0),
+  add(N0, 1.0, N),
+  add(SumX0, X, SumX),
+  add(SumY0, Y, SumY),
+  mul(X, X, XX),
+  add(SumXX0, XX, SumXX),
+  mul(X, Y, XY),
+  add(SumXY0, XY, SumXY),
+  mul(Y, Y, YY),
+  add(SumYY0, YY, SumYY).
+
+sufficient_statistics(Data, N, SumX, SumY, SumXX, SumXY, SumYY) :-
+  dataset(Data, Points),
+  stats(Points, N, SumX, SumY, SumXX, SumXY, SumYY).
+
+slope(Data, Slope) :-
+  sufficient_statistics(Data, N, SumX, SumY, SumXX, SumXY, _SumYY),
+  mul(N, SumXY, NSumXY),
+  mul(SumX, SumY, SumXSumY),
+  sub(NSumXY, SumXSumY, Numerator),
+  mul(N, SumXX, NSumXX),
+  mul(SumX, SumX, SumXSquared),
+  sub(NSumXX, SumXSquared, Denominator),
+  div(Numerator, Denominator, Slope).
+
+intercept(Data, Intercept) :-
+  sufficient_statistics(Data, N, SumX, SumY, _SumXX, _SumXY, _SumYY),
+  slope(Data, Slope),
+  mul(Slope, SumX, SlopeSumX),
+  sub(SumY, SlopeSumX, Numerator),
+  div(Numerator, N, Intercept).
+
+r_squared(Data, R2) :-
+  sufficient_statistics(Data, N, SumX, SumY, SumXX, SumXY, SumYY),
+  mul(N, SumXY, NSumXY),
+  mul(SumX, SumY, SumXSumY),
+  sub(NSumXY, SumXSumY, NumeratorBase),
+  pow(NumeratorBase, 2.0, Numerator),
+  mul(N, SumXX, NSumXX),
+  mul(SumX, SumX, SumXSquared),
+  sub(NSumXX, SumXSquared, XSpread),
+  mul(N, SumYY, NSumYY),
+  mul(SumY, SumY, SumYSquared),
+  sub(NSumYY, SumYSquared, YSpread),
+  mul(XSpread, YSpread, Denominator),
+  div(Numerator, Denominator, R2).
+
+accepted_fit(Data) :-
+  r_squared(Data, R2),
+  threshold(Data, minimum_r_squared, Minimum),
+  ge(R2, Minimum).
+
+
+
+rSquared(Data, R2) :-
+  r_squared(Data, R2).
+
+status(Data, accepted_linear_fit) :-
+  accepted_fit(Data).
+
+reason(Data, "R squared meets the minimum explanatory-power threshold") :-
+  accepted_fit(Data).

package/examples/eyelang/list-collection.pl

@@ -0,0 +1,33 @@
+% List collections inspired by the Eyeling collection example.
+% Demonstrates list literals, member/2, length/2, append/3, and [Head|Tail].
+% Each materialized relation demonstrates one list operation.
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(length, 2).
+materialize(member, 2).
+materialize(append, 2).
+materialize(head, 2).
+materialize(tail, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+% Lists are first-class terms in facts and rule heads/bodies.
+collection(numbers, [1, 2, 3]).
+collection(letters, [a, b]).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+length(numbers, N) :-
+  collection(numbers, List),
+  length(List, N).
+
+member(numbers, X) :-
+  collection(numbers, List),
+  member(X, List).
+
+append(letters, Extended) :-
+  collection(letters, List),
+  append(List, [c], Extended).
+
+head(letters, Head) :-
+  collection(letters, [Head|_Tail]).
+
+tail(letters, Tail) :-
+  collection(letters, [_Head|Tail]).