eyeling 1.34.3 → 1.34.5

package/examples/eyelang/goldbach-1000.pl

@@ -1,185 +0,0 @@
-% Goldbach pairs up to 1000.
-% Prime numbers are input data; the rule below derives all Goldbach pairs.
-% Output declarations: materialize/2 selects the relations written to this example's golden output.
-materialize(isPrime, 2).
-materialize(goldbachOk, 2).
-
-% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
-prime(2).
-prime(3).
-prime(5).
-prime(7).
-prime(11).
-prime(13).
-prime(17).
-prime(19).
-prime(23).
-prime(29).
-prime(31).
-prime(37).
-prime(41).
-prime(43).
-prime(47).
-prime(53).
-prime(59).
-prime(61).
-prime(67).
-prime(71).
-prime(73).
-prime(79).
-prime(83).
-prime(89).
-prime(97).
-prime(101).
-prime(103).
-prime(107).
-prime(109).
-prime(113).
-prime(127).
-prime(131).
-prime(137).
-prime(139).
-prime(149).
-prime(151).
-prime(157).
-prime(163).
-prime(167).
-prime(173).
-prime(179).
-prime(181).
-prime(191).
-prime(193).
-prime(197).
-prime(199).
-prime(211).
-prime(223).
-prime(227).
-prime(229).
-prime(233).
-prime(239).
-prime(241).
-prime(251).
-prime(257).
-prime(263).
-prime(269).
-prime(271).
-prime(277).
-prime(281).
-prime(283).
-prime(293).
-prime(307).
-prime(311).
-prime(313).
-prime(317).
-prime(331).
-prime(337).
-prime(347).
-prime(349).
-prime(353).
-prime(359).
-prime(367).
-prime(373).
-prime(379).
-prime(383).
-prime(389).
-prime(397).
-prime(401).
-prime(409).
-prime(419).
-prime(421).
-prime(431).
-prime(433).
-prime(439).
-prime(443).
-prime(449).
-prime(457).
-prime(461).
-prime(463).
-prime(467).
-prime(479).
-prime(487).
-prime(491).
-prime(499).
-prime(503).
-prime(509).
-prime(521).
-prime(523).
-prime(541).
-prime(547).
-prime(557).
-prime(563).
-prime(569).
-prime(571).
-prime(577).
-prime(587).
-prime(593).
-prime(599).
-prime(601).
-prime(607).
-prime(613).
-prime(617).
-prime(619).
-prime(631).
-prime(641).
-prime(643).
-prime(647).
-prime(653).
-prime(659).
-prime(661).
-prime(673).
-prime(677).
-prime(683).
-prime(691).
-prime(701).
-prime(709).
-prime(719).
-prime(727).
-prime(733).
-prime(739).
-prime(743).
-prime(751).
-prime(757).
-prime(761).
-prime(769).
-prime(773).
-prime(787).
-prime(797).
-prime(809).
-prime(811).
-prime(821).
-prime(823).
-prime(827).
-prime(829).
-prime(839).
-prime(853).
-prime(857).
-prime(859).
-prime(863).
-prime(877).
-prime(881).
-prime(883).
-prime(887).
-prime(907).
-prime(911).
-prime(919).
-prime(929).
-prime(937).
-prime(941).
-prime(947).
-prime(953).
-prime(967).
-prime(971).
-prime(977).
-prime(983).
-prime(991).
-prime(997).
-
-% Derivation rules: each rule below contributes one logical step toward the displayed results.
-even_between_4_1000(N) :- between(4, 1000, N), mod(N, 2, 0).
-
-isPrime(N, true) :-
-  prime(N).
-
-goldbachOk(N, true) :-
-  even_between_4_1000(N),
-  goldbach_pair(N, _P, _Q).

package/examples/eyelang/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/eyelang/matrix.pl

@@ -1,296 +0,0 @@
-% Matrix operations example, adapted from Eyelet's input/matrix.pl.
-%
-% The operations and sample cases follow the Trealla output reference from
-% Eyelet: determinant, inversion, triangular inversion, multiplication, sum,
-% and Cholesky decomposition.  Results are derived by generic matrix rules, not
-% asserted as output facts.
-
-% --- small list helpers -----------------------------------------------------
-
-% Output declarations: materialize/2 selects the relations written to this example's golden output.
-materialize(result, 2).
-materialize(checksConsistentWithTreallaReference, 2).
-
-% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
-nth0(0, [H|_T], H).
-% Derivation rules: each rule below contributes one logical step toward the displayed results.
-nth0(N, [_H|T], V) :-
-  gt(N, 0),
-  sub(N, 1, N1),
-  nth0(N1, T, V).
-
-flatten_matrix([], []).
-flatten_matrix([Row|Rows], Flat) :-
-  flatten_matrix(Rows, Tail),
-  append(Row, Tail, Flat).
-
-list0(0, []).
-list0(N, [0|T]) :-
-  gt(N, 0),
-  sub(N, 1, N1),
-  list0(N1, T).
-
-take(0, Rest, [], Rest).
-take(N, [H|T], [H|Row], Rest) :-
-  gt(N, 0),
-  sub(N, 1, N1),
-  take(N1, T, Row, Rest).
-
-identify_rows([], _N, []).
-identify_rows(Elems, N, [Row|Rows]) :-
-  take(N, Elems, Row, Rest),
-  identify_rows(Rest, N, Rows).
-
-get_v(I, J, N, Flat, V) :-
-  mul(I, N, IN),
-  add(IN, J, E),
-  nth0(E, Flat, V).
-
-set_v(I, J, N, Flat, NewFlat, V) :-
-  mul(I, N, IN),
-  add(IN, J, E),
-  set_nth0(E, Flat, V, NewFlat).
-
-% --- basic matrix operations ------------------------------------------------
-
-row_sum([], [], []).
-row_sum([A|As], [B|Bs], [C|Cs]) :-
-  add(A, B, C),
-  row_sum(As, Bs, Cs).
-
-matrix_sum([[], []], []).
-matrix_sum([[RowA|RowsA], [RowB|RowsB]], [Row|Rows]) :-
-  row_sum(RowA, RowB, Row),
-  matrix_sum([RowsA, RowsB], Rows).
-
-row_diff([], [], []).
-row_diff([A|As], [B|Bs], [C|Cs]) :-
-  sub(A, B, C),
-  row_diff(As, Bs, Cs).
-
-matrix_diff([], [], []).
-matrix_diff([RowA|RowsA], [RowB|RowsB], [Row|Rows]) :-
-  row_diff(RowA, RowB, Row),
-  matrix_diff(RowsA, RowsB, Rows).
-
-row_mult_scal([], _V, []).
-row_mult_scal([A|As], V, [B|Bs]) :-
-  mul(A, V, B),
-  row_mult_scal(As, V, Bs).
-
-matrix_mult_scal([], _V, []).
-matrix_mult_scal([Row|Rows], V, [Scaled|ScaledRows]) :-
-  row_mult_scal(Row, V, Scaled),
-  matrix_mult_scal(Rows, V, ScaledRows).
-
-row_div_scal([], _V, []).
-row_div_scal([A|As], V, [B|Bs]) :-
-  div(A, V, B),
-  row_div_scal(As, V, Bs).
-
-matrix_div_scal([], _V, []).
-matrix_div_scal([Row|Rows], V, [Scaled|ScaledRows]) :-
-  row_div_scal(Row, V, Scaled),
-  matrix_div_scal(Rows, V, ScaledRows).
-
-transpose_matrix([], []).
-transpose_matrix([[]|_Rows], []).
-transpose_matrix(Matrix, [Column|Columns]) :-
-  first_column(Matrix, Column, Rest),
-  transpose_matrix(Rest, Columns).
-
-first_column([], [], []).
-first_column([[H|T]|Rows], [H|Hs], [T|Ts]) :-
-  first_column(Rows, Hs, Ts).
-
-dot_product([], [], 0).
-dot_product([X|Xs], [Y|Ys], D) :-
-  dot_product(Xs, Ys, Rest),
-  mul(X, Y, XY),
-  add(XY, Rest, D).
-
-row_multiply(_Transposed, [], []).
-row_multiply(Transposed, [Row|Rows], [OutRow|OutRows]) :-
-  row_multiply_columns(Transposed, Row, OutRow),
-  row_multiply(Transposed, Rows, OutRows).
-
-row_multiply_columns([], _Row, []).
-row_multiply_columns([Column|Columns], Row, [D|Ds]) :-
-  dot_product(Row, Column, D),
-  row_multiply_columns(Columns, Row, Ds).
-
-matrix_multiply([X, Y], M) :-
-  transpose_matrix(Y, T),
-  row_multiply(T, X, M).
-
-% --- Cholesky decomposition -------------------------------------------------
-
-cholesky_decomposition(A, L) :-
-  flatten_matrix(A, FlatA),
-  length(FlatA, FlatLen),
-  list0(FlatLen, Work0),
-  length(A, N),
-  cholesky_i(0, N, FlatA, Work0, Work),
-  identify_rows(Work, N, L).
-
-cholesky_i(I, N, _A, L, L) :-
-  ge(I, N).
-cholesky_i(I, N, A, L, LOut) :-
-  lt(I, N),
-  cholesky_j(0, I, N, A, L, L1),
-  add(I, 1, I1),
-  cholesky_i(I1, N, A, L1, LOut).
-
-cholesky_j(J, I, N, A, L, LOut) :-
-  eq(J, I),
-  cholesky_k(0, I, I, N, 0, S, L),
-  get_v(I, I, N, A, Aii),
-  sub(Aii, S, V2),
-  pow(V2, 0.5, V),
-  set_v(I, I, N, L, LOut, V).
-cholesky_j(J, I, N, A, L, LOut) :-
-  lt(J, I),
-  cholesky_k(0, J, I, N, 0, S, L),
-  get_v(I, J, N, A, Aij),
-  get_v(J, J, N, L, Ljj),
-  sub(Aij, S, Numerator),
-  div(Numerator, Ljj, V),
-  set_v(I, J, N, L, L1, V),
-  add(J, 1, J1),
-  cholesky_j(J1, I, N, A, L1, LOut).
-
-cholesky_k(K, J, _I, _N, S, S, _L) :-
-  ge(K, J).
-cholesky_k(K, J, I, N, S0, S, L) :-
-  lt(K, J),
-  get_v(I, K, N, L, Lik),
-  get_v(J, K, N, L, Ljk),
-  mul(Lik, Ljk, Product),
-  add(S0, Product, S1),
-  add(K, 1, K1),
-  cholesky_k(K1, J, I, N, S1, S, L).
-
-% --- determinant and inversion ---------------------------------------------
-
-get_diagonal(Matrix, Diagonal) :-
-  length(Matrix, N),
-  get_diag(0, N, Matrix, Diagonal).
-
-get_diag(I, N, _Matrix, []) :-
-  ge(I, N).
-get_diag(I, N, Matrix, [V|Vs]) :-
-  lt(I, N),
-  nth0(I, Matrix, Row),
-  nth0(I, Row, V),
-  add(I, 1, I1),
-  get_diag(I1, N, Matrix, Vs).
-
-prod_list([], 1).
-prod_list([A|As], P) :-
-  prod_list(As, P0),
-  mul(A, P0, P).
-
-determinant(A, Det) :-
-  cholesky_decomposition(A, L),
-  get_diagonal(L, Diagonal),
-  prod_list(Diagonal, DetL),
-  mul(DetL, DetL, Det).
-
-matrix_inv_triang(L, Inv) :-
-  length(L, N),
-  build_inv_rows(0, N, L, [], Inv).
-
-build_inv_rows(I, N, _L, _Previous, []) :-
-  ge(I, N).
-build_inv_rows(I, N, L, Previous, [Row|Rows]) :-
-  lt(I, N),
-  build_inv_row(0, N, I, L, Previous, Row),
-  append(Previous, [Row], NextPrevious),
-  add(I, 1, I1),
-  build_inv_rows(I1, N, L, NextPrevious, Rows).
-
-build_inv_row(J, N, _I, _L, _Previous, []) :-
-  ge(J, N).
-build_inv_row(J, N, I, L, Previous, [V|Vs]) :-
-  lt(J, N),
-  lower_inverse_value(I, J, N, L, Previous, V),
-  add(J, 1, J1),
-  build_inv_row(J1, N, I, L, Previous, Vs).
-
-lower_inverse_value(I, J, _N, _L, _Previous, 0) :-
-  gt(J, I).
-lower_inverse_value(I, J, N, L, _Previous, V) :-
-  eq(I, J),
-  nth0(I, L, Row),
-  nth0(I, Row, Diagonal),
-  div(1.0, Diagonal, V).
-lower_inverse_value(I, J, N, L, Previous, V) :-
-  lt(J, I),
-  sum_lower_inverse(J, I, J, N, L, Previous, 0, Sum),
-  neg(Sum, NegSum),
-  nth0(I, L, Row),
-  nth0(I, Row, Diagonal),
-  div(NegSum, Diagonal, V).
-
-sum_lower_inverse(K, I, _J, _N, _L, _Previous, Sum, Sum) :-
-  ge(K, I).
-sum_lower_inverse(K, I, J, N, L, Previous, Sum0, Sum) :-
-  lt(K, I),
-  nth0(I, L, RowI),
-  nth0(K, RowI, Lik),
-  nth0(K, Previous, InvRowK),
-  nth0(J, InvRowK, InvKj),
-  mul(Lik, InvKj, Product),
-  add(Sum0, Product, Sum1),
-  add(K, 1, K1),
-  sum_lower_inverse(K1, I, J, N, L, Previous, Sum1, Sum).
-
-matrix_inversion(A, B) :-
-  cholesky_decomposition(A, L),
-  matrix_inv_triang(L, LI),
-  transpose_matrix(LI, LIT),
-  matrix_multiply([LIT, LI], B).
-
-% --- sample cases mirroring Eyelet's Trealla reference output ---------------
-
-case(det3, determinant, [[2, -1, 0], [-1, 2, -1], [0, -1, 2]]).
-case(inv3, matrix_inversion, [[2, -1, 0], [-1, 2, -1], [0, -1, 2]]).
-case(inv4, matrix_inversion, [[18, 22, 54, 42], [22, 70, 86, 62], [54, 86, 174, 134], [42, 62, 134, 106]]).
-case(invtri3, matrix_inv_triang, [[2, 0, 0], [-1, 2, 0], [0, -1, 2]]).
-case(mul_small, matrix_multiply, [[[1, 2], [3, 4], [5, 6]], [[1, 1, 1], [1, 1, 1]]]).
-case(mul_identity_check, matrix_multiply, [[[18, 22, 54, 42], [22, 70, 86, 62], [54, 86, 174, 134], [42, 62, 134, 106]], [[2.515624999999984, 0.4843749999999933, -1.296874999999973, 0.3593749999999767], [0.4843749999999933, 0.1406249999999978, -0.3281249999999918, 0.1406249999999936], [-1.296874999999973, -0.3281249999999918, 1.015624999999971, -0.5781249999999781], [0.3593749999999767, 0.1406249999999936, -0.5781249999999781, 0.5156249999999853]]]).
-case(sum_small, matrix_sum, [[[1, 2], [3, 4], [5, 6]], [[1, 2], [3, 4], [5, 6]]]).
-case(chol3, cholesky_decomposition, [[25, 15, -5], [15, 18, 0], [-5, 0, 11]]).
-case(chol4, cholesky_decomposition, [[18, 22, 54, 42], [22, 70, 86, 62], [54, 86, 174, 134], [42, 62, 134, 106]]).
-
-result(Case, determinant(Matrix, Det)) :-
-  case(Case, determinant, Matrix),
-  determinant(Matrix, Det).
-
-result(Case, matrix_inversion(Matrix, Inverse)) :-
-  case(Case, matrix_inversion, Matrix),
-  matrix_inversion(Matrix, Inverse).
-
-result(Case, matrix_inv_triang(Matrix, Inverse)) :-
-  case(Case, matrix_inv_triang, Matrix),
-  matrix_inv_triang(Matrix, Inverse).
-
-result(Case, matrix_multiply(Inputs, Product)) :-
-  case(Case, matrix_multiply, Inputs),
-  matrix_multiply(Inputs, Product).
-
-result(Case, matrix_sum(Inputs, Sum)) :-
-  case(Case, matrix_sum, Inputs),
-  matrix_sum(Inputs, Sum).
-
-result(Case, cholesky_decomposition(Matrix, L)) :-
-  case(Case, cholesky_decomposition, Matrix),
-  cholesky_decomposition(Matrix, L).
-
-checksConsistentWithTreallaReference(matrix, true) :-
-  determinant([[2, -1, 0], [-1, 2, -1], [0, -1, 2]], Det),
-  gt(Det, 3.9999),
-  lt(Det, 4.0001),
-  matrix_multiply([[[1, 2], [3, 4], [5, 6]], [[1, 1, 1], [1, 1, 1]]], [[3, 3, 3], [7, 7, 7], [11, 11, 11]]),
-  matrix_sum([[[1, 2], [3, 4], [5, 6]], [[1, 2], [3, 4], [5, 6]]], [[2, 4], [6, 8], [10, 12]]),
-  cholesky_decomposition([[25, 15, -5], [15, 18, 0], [-5, 0, 11]], [[5.0, 0, 0], [3.0, 3.0, 0], [-1.0, 1.0, 3.0]]).