eyelang 1.6.0 → 1.7.0

package/examples/group-inverse-uniqueness.pl

@@ -1,34 +0,0 @@
-% 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/hamiltonian-cycle.pl

@@ -1,55 +0,0 @@
-% 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/hamiltonian-path.pl

@@ -1,49 +0,0 @@
-% 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/hamming-code.pl

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

@@ -1,20 +0,0 @@
-% 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/heat-loss.pl

@@ -1,51 +0,0 @@
-% 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/heron-theorem.pl

@@ -1,36 +0,0 @@
-% 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/ideal-gas-law.pl

@@ -1,37 +0,0 @@
-% 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/illegitimate-reasoning.pl

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

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

@@ -1,31 +0,0 @@
-% 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/least-squares-regression.pl

@@ -1,81 +0,0 @@
-% 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/list-collection.pl

@@ -1,33 +0,0 @@
-% 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]).