eyeling 1.32.1 → 1.33.1

package/examples/eyelang/lldm.pl

@@ -0,0 +1,78 @@
+% Leg Length Discrepancy Measurement, adapted from Eyeling lldm.n3.
+%
+% The measurement and intermediate geometry are kept in helper predicates so
+% the default relation materialization stays concise.  The visible output is
+% the alarm plus the small set of relations explaining why the alarm fired.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(type, 2).
+materialize(lld_left_length_cm, 2).
+materialize(lld_right_length_cm, 2).
+materialize(lld_discrepancy_cm, 2).
+materialize(lld_threshold_cm, 2).
+materialize(lld_reason, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+measurement(meas47).
+
+% measured landmark coordinates, in centimetres
+val(meas47, p1xCm, 10.1).
+val(meas47, p1yCm, 7.8).
+val(meas47, p2xCm, 45.1).
+val(meas47, p2yCm, 5.6).
+val(meas47, p3xCm, 3.6).
+val(meas47, p3yCm, 29.8).
+val(meas47, p4xCm, 54.7).
+val(meas47, p4yCm, 28.5).
+
+% threshold used by the alarm rule, in centimetres
+threshold(meas47, lld_alarm_threshold_cm, 1.25).
+
+% geometric intermediate values
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+val(M, dx12Cm, Z) :- measurement(M), val(M, p1xCm, X), val(M, p2xCm, Y), sub(X, Y, Z).
+val(M, dx51Cm, Z) :- measurement(M), val(M, p5xCm, X), val(M, p1xCm, Y), sub(X, Y, Z).
+val(M, dx53Cm, Z) :- measurement(M), val(M, p5xCm, X), val(M, p3xCm, Y), sub(X, Y, Z).
+val(M, dx62Cm, Z) :- measurement(M), val(M, p6xCm, X), val(M, p2xCm, Y), sub(X, Y, Z).
+val(M, dx64Cm, Z) :- measurement(M), val(M, p6xCm, X), val(M, p4xCm, Y), sub(X, Y, Z).
+val(M, dy12Cm, Z) :- measurement(M), val(M, p1yCm, X), val(M, p2yCm, Y), sub(X, Y, Z).
+val(M, dy13Cm, Z) :- measurement(M), val(M, p1yCm, X), val(M, p3yCm, Y), sub(X, Y, Z).
+val(M, dy24Cm, Z) :- measurement(M), val(M, p2yCm, X), val(M, p4yCm, Y), sub(X, Y, Z).
+val(M, dy53Cm, Z) :- measurement(M), val(M, p5yCm, X), val(M, p3yCm, Y), sub(X, Y, Z).
+val(M, dy64Cm, Z) :- measurement(M), val(M, p6yCm, X), val(M, p4yCm, Y), sub(X, Y, Z).
+val(M, cL1, Z) :- measurement(M), val(M, dy12Cm, Y), val(M, dx12Cm, X), div(Y, X, Z).
+val(M, dL3m, Z) :- measurement(M), val(M, cL1, X), div(1, X, Z).
+val(M, cL3, Z) :- measurement(M), val(M, dL3m, X), sub(0, X, Z).
+val(M, pL1x1Cm, Z) :- measurement(M), val(M, cL1, X), val(M, p1xCm, Y), mul(X, Y, Z).
+val(M, pL1x2Cm, Z) :- measurement(M), val(M, cL1, X), val(M, p2xCm, Y), mul(X, Y, Z).
+val(M, pL3x3Cm, Z) :- measurement(M), val(M, cL3, X), val(M, p3xCm, Y), mul(X, Y, Z).
+val(M, pL3x4Cm, Z) :- measurement(M), val(M, cL3, X), val(M, p4xCm, Y), mul(X, Y, Z).
+val(M, dd13Cm, Z) :- measurement(M), val(M, pL1x1Cm, X), val(M, pL3x3Cm, Y), sub(X, Y, Z).
+val(M, ddy13Cm, Z) :- measurement(M), val(M, dd13Cm, X), val(M, dy13Cm, Y), sub(X, Y, Z).
+val(M, dd24Cm, Z) :- measurement(M), val(M, pL1x2Cm, X), val(M, pL3x4Cm, Y), sub(X, Y, Z).
+val(M, ddy24Cm, Z) :- measurement(M), val(M, dd24Cm, X), val(M, dy24Cm, Y), sub(X, Y, Z).
+val(M, ddL13, Z) :- measurement(M), val(M, cL1, X), val(M, cL3, Y), sub(X, Y, Z).
+val(M, pL1dx51Cm, Z) :- measurement(M), val(M, cL1, X), val(M, dx51Cm, Y), mul(X, Y, Z).
+val(M, pL1dx62Cm, Z) :- measurement(M), val(M, cL1, X), val(M, dx62Cm, Y), mul(X, Y, Z).
+val(M, p5xCm, Z) :- measurement(M), val(M, ddy13Cm, X), val(M, ddL13, Y), div(X, Y, Z).
+val(M, p5yCm, Z) :- measurement(M), val(M, pL1dx51Cm, X), val(M, p1yCm, Y), add(X, Y, Z).
+val(M, p6xCm, Z) :- measurement(M), val(M, ddy24Cm, X), val(M, ddL13, Y), div(X, Y, Z).
+val(M, p6yCm, Z) :- measurement(M), val(M, pL1dx62Cm, X), val(M, p2yCm, Y), add(X, Y, Z).
+val(M, sdx53Cm2, Z) :- measurement(M), val(M, dx53Cm, X), pow(X, 2, Z).
+val(M, sdx64Cm2, Z) :- measurement(M), val(M, dx64Cm, X), pow(X, 2, Z).
+val(M, sdy53Cm2, Z) :- measurement(M), val(M, dy53Cm, X), pow(X, 2, Z).
+val(M, sdy64Cm2, Z) :- measurement(M), val(M, dy64Cm, X), pow(X, 2, Z).
+val(M, ssd53Cm2, Z) :- measurement(M), val(M, sdx53Cm2, X), val(M, sdy53Cm2, Y), add(X, Y, Z).
+val(M, ssd64Cm2, Z) :- measurement(M), val(M, sdx64Cm2, X), val(M, sdy64Cm2, Y), add(X, Y, Z).
+val(M, d53Cm, Z) :- measurement(M), val(M, ssd53Cm2, X), pow(X, 0.5, Z).
+val(M, d64Cm, Z) :- measurement(M), val(M, ssd64Cm2, X), pow(X, 0.5, Z).
+val(M, dCm, Z) :- measurement(M), val(M, d53Cm, X), val(M, d64Cm, Y), sub(X, Y, Z).
+
+% concise output layer
+type(M, lld_alarm) :- measurement(M), val(M, dCm, D), threshold(M, lld_alarm_threshold_cm, T), sub(0, T, NegT), lt(D, NegT).
+type(M, lld_alarm) :- measurement(M), val(M, dCm, D), threshold(M, lld_alarm_threshold_cm, T), gt(D, T).
+lld_left_length_cm(M, L) :- type(M, lld_alarm), val(M, d53Cm, L).
+lld_right_length_cm(M, R) :- type(M, lld_alarm), val(M, d64Cm, R).
+lld_discrepancy_cm(M, D) :- type(M, lld_alarm), val(M, dCm, D).
+lld_threshold_cm(M, T) :- type(M, lld_alarm), threshold(M, lld_alarm_threshold_cm, T).
+lld_reason(M, "discrepancy below negative threshold") :- type(M, lld_alarm).

package/examples/eyelang/manufacturing-quality-control.pl

@@ -0,0 +1,73 @@
+% Representative example: manufacturing quality-control capability.
+%
+% The rules compute process capability indices from measurement summaries and
+% classify production lines using a practical Cpk threshold.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(cpk, 2).
+materialize(status, 2).
+materialize(reason, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+run(line7_shift_a).
+run(line8_shift_b).
+
+spec(line7_shift_a, lower_mm, 10.0).
+spec(line7_shift_a, upper_mm, 10.2).
+summary(line7_shift_a, mean_mm, 10.12).
+summary(line7_shift_a, sigma_mm, 0.04).
+
+spec(line8_shift_b, lower_mm, 10.0).
+spec(line8_shift_b, upper_mm, 10.2).
+summary(line8_shift_b, mean_mm, 10.1).
+summary(line8_shift_b, sigma_mm, 0.02).
+
+capability_threshold(cpk, 1.33).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+upper_margin_mm(Run, Margin) :-
+  spec(Run, upper_mm, Upper),
+  summary(Run, mean_mm, Mean),
+  sub(Upper, Mean, Margin).
+
+lower_margin_mm(Run, Margin) :-
+  summary(Run, mean_mm, Mean),
+  spec(Run, lower_mm, Lower),
+  sub(Mean, Lower, Margin).
+
+nearest_spec_margin_mm(Run, Margin) :-
+  upper_margin_mm(Run, UpperMargin),
+  lower_margin_mm(Run, LowerMargin),
+  min(UpperMargin, LowerMargin, Margin).
+
+three_sigma_mm(Run, ThreeSigma) :-
+  summary(Run, sigma_mm, Sigma),
+  mul(3.0, Sigma, ThreeSigma).
+
+cpk(Run, Cpk) :-
+  nearest_spec_margin_mm(Run, Margin),
+  three_sigma_mm(Run, ThreeSigma),
+  div(Margin, ThreeSigma, Cpk).
+
+capable(Run) :-
+  cpk(Run, Cpk),
+  capability_threshold(cpk, Threshold),
+  ge(Cpk, Threshold).
+
+needs_adjustment(Run) :-
+  cpk(Run, Cpk),
+  capability_threshold(cpk, Threshold),
+  lt(Cpk, Threshold).
+
+
+status(Run, capable_process) :-
+  capable(Run).
+
+status(Run, needs_process_adjustment) :-
+  needs_adjustment(Run).
+
+reason(Run, "Cpk meets the production capability threshold") :-
+  capable(Run).
+
+reason(Run, "Cpk is below the production capability threshold") :-
+  needs_adjustment(Run).

package/examples/eyelang/matrix.pl

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

package/examples/eyelang/microgrid-dispatch.pl

@@ -0,0 +1,85 @@
+% Representative example: microgrid dispatch planning.
+%
+% The rules compute renewable supply, reserve-aware battery dispatch, remaining
+% grid import, and a concise feasibility report for a campus microgrid interval.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(renewablePower_kW, 2).
+materialize(batteryDispatch_kW, 2).
+materialize(gridImport_kW, 2).
+materialize(reserveAfterDispatch_kW, 2).
+materialize(status, 2).
+materialize(reason, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+site(campus_interval_17).
+
+load_kW(campus_interval_17, 620.0).
+solar_kW(campus_interval_17, 180.0).
+wind_kW(campus_interval_17, 90.0).
+battery_max_discharge_kW(campus_interval_17, 320.0).
+required_battery_reserve_kW(campus_interval_17, 80.0).
+grid_contract_limit_kW(campus_interval_17, 150.0).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+renewable_kW(Site, Renewable) :-
+  solar_kW(Site, Solar),
+  wind_kW(Site, Wind),
+  add(Solar, Wind, Renewable).
+
+net_deficit_kW(Site, Deficit) :-
+  load_kW(Site, Load),
+  renewable_kW(Site, Renewable),
+  sub(Load, Renewable, Deficit).
+
+reserve_aware_battery_limit_kW(Site, Limit) :-
+  battery_max_discharge_kW(Site, MaxDischarge),
+  required_battery_reserve_kW(Site, Reserve),
+  sub(MaxDischarge, Reserve, Limit).
+
+battery_dispatch_kW(Site, Dispatch) :-
+  net_deficit_kW(Site, Deficit),
+  reserve_aware_battery_limit_kW(Site, Limit),
+  min(Deficit, Limit, Dispatch).
+
+grid_import_kW(Site, Import) :-
+  net_deficit_kW(Site, Deficit),
+  battery_dispatch_kW(Site, Dispatch),
+  sub(Deficit, Dispatch, Import).
+
+battery_reserve_after_dispatch_kW(Site, ReserveLeft) :-
+  battery_max_discharge_kW(Site, MaxDischarge),
+  battery_dispatch_kW(Site, Dispatch),
+  sub(MaxDischarge, Dispatch, ReserveLeft).
+
+contract_ok(Site) :-
+  grid_import_kW(Site, Import),
+  grid_contract_limit_kW(Site, Limit),
+  le(Import, Limit).
+
+reserve_ok(Site) :-
+  battery_reserve_after_dispatch_kW(Site, ReserveLeft),
+  required_battery_reserve_kW(Site, Required),
+  ge(ReserveLeft, Required).
+
+stable_dispatch(Site) :-
+  contract_ok(Site),
+  reserve_ok(Site).
+
+renewablePower_kW(Site, Renewable) :-
+  renewable_kW(Site, Renewable).
+
+batteryDispatch_kW(Site, Dispatch) :-
+  battery_dispatch_kW(Site, Dispatch).
+
+gridImport_kW(Site, Import) :-
+  grid_import_kW(Site, Import).
+
+reserveAfterDispatch_kW(Site, ReserveLeft) :-
+  battery_reserve_after_dispatch_kW(Site, ReserveLeft).
+
+status(Site, stable_dispatch) :-
+  stable_dispatch(Site).
+
+reason(Site, "battery dispatch covers the deficit while preserving reserve and grid contract limits") :-
+  stable_dispatch(Site).

package/examples/eyelang/monkey-bananas.pl

@@ -0,0 +1,45 @@
+% Monkey and bananas planning problem, adapted from Eyelet's
+% input/monkey-bananas.pl.
+%
+% A state is [bananas_location, monkey_location, box_location, on_box,
+% has_bananas].  The selected output searches bounded move lists and derives successful
+% plans.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(plan, 2).
+materialize(solved, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+memoize(reachable, 3).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+plan(Moves) :-
+  candidate_plan(Moves),
+  initial_state(I),
+  goal_state(G),
+  reachable(I, Moves, G).
+
+candidate_plan([_, _, _]).
+candidate_plan([_, _, _, _]).
+candidate_plan([_, _, _, _, _]).
+
+reachable(S, [], S).
+reachable(S1, [M|L], S3) :-
+  legal_move(S1, M, S2),
+  reachable(S2, L, S3).
+
+initial_state([loc1, loc2, loc3, n, n]).
+goal_state([_, _, _, _, y]).
+
+legal_move([B, M, M, n, H], climb_on, [B, M, M, y, H]).
+legal_move([B, M, M, y, H], climb_off, [B, M, M, n, H]).
+legal_move([B, B, B, y, n], grab, [B, B, B, y, y]).
+legal_move([B, M, M, n, H], push(X), [B, X, X, n, H]) :-
+  member(X, [loc1, loc2, loc3]),
+  neq(X, M).
+legal_move([B, M, L, n, H], go(X), [B, X, L, n, H]) :-
+  member(X, [loc1, loc2, loc3]),
+  neq(X, M).
+
+plan(monkeyBananas, Moves) :- plan(Moves).
+solved(monkeyBananas, true) :- plan(_Moves).

package/examples/eyelang/n-queens.pl

@@ -0,0 +1,23 @@
+% N-queens search without cut.
+%
+% A solution is represented as a list of column numbers.  The list position is
+% the row, so [1, 5, 8, ...] means row 1 uses column 1, row 2 uses column 5,
+% and so on.  Columns are selected from a finite list, which guarantees that no
+% two queens share a column.
+%
+% The two diagonal sets are carried as accumulator lists.  A queen at
+% row Row/column Q occupies the down diagonal Row + Q and the up diagonal
+% Row - Q.  Rejecting repeats in those two lists enforces the remaining
+% N-queens constraints declaratively, without cut or destructive update.
+
+% 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.
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+queens(N, Qs) :-
+  n_queens(N, Qs).
+
+solution(nQueens8, Qs) :- queens(8, Qs).
+solved(nQueens8, true) :- queens(8, _Qs).

package/examples/eyelang/n3-builtins.n3

@@ -0,0 +1,28 @@
+@prefix : <http://example.com/> .
+@prefix math: <http://www.w3.org/2000/10/swap/math#> .
+@prefix string: <http://www.w3.org/2000/10/swap/string#> .
+@prefix list: <http://www.w3.org/2000/10/swap/list#> .
+
+:alice :score 2 ; :bonus 3 ; :name "Alice" .
+:bob :score 1 ; :bonus 1 ; :name "Bob" .
+
+{ ?person :score ?score .
+  ?person :bonus ?bonus .
+  (?score ?bonus) math:sum ?total .
+  ?total math:greaterThan 4 .
+  ?person :name ?name .
+  ?name string:startsWith "Al" .
+  (?name " total " ?total) string:concatenation ?label .
+} => {
+  ?person :total ?total .
+  ?person :label ?label .
+} .
+
+{ ?person :status :passing . } <= {
+  ?person :total ?total .
+  ?total math:notLessThan 5 .
+} .
+
+{ (:red :green :blue) list:member ?colour . } => {
+  ?colour :kind :colour .
+} .

package/examples/eyelang/network-sla.pl

@@ -0,0 +1,48 @@
+% Technology example: network path SLA check.
+%
+% The path latency is the sum of link delays plus jitter. The path is compliant
+% when the resulting end-to-end latency stays below the SLA limit.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(endToEndLatency_ms, 2).
+materialize(slaLimit_ms, 2).
+materialize(status, 2).
+materialize(reason, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+path(edge_path, [link_a, link_b, link_c]).
+link_latency(link_a, 12.0).
+link_latency(link_b, 18.0).
+link_latency(link_c, 9.0).
+jitter(edge_path, 8.0).
+sla(edge_path, maximum_latency_ms, 50.0).
+
+latency_sum([], 0.0).
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+latency_sum([Link|Links], Total) :-
+  link_latency(Link, LinkLatency),
+  latency_sum(Links, Rest),
+  add(LinkLatency, Rest, Total).
+
+end_to_end_latency(Path, Latency) :-
+  path(Path, Links),
+  latency_sum(Links, LinkLatency),
+  jitter(Path, Jitter),
+  add(LinkLatency, Jitter, Latency).
+
+sla_compliant(Path) :-
+  end_to_end_latency(Path, Latency),
+  sla(Path, maximum_latency_ms, Maximum),
+  lt(Latency, Maximum).
+
+endToEndLatency_ms(Path, Latency) :-
+  end_to_end_latency(Path, Latency).
+
+slaLimit_ms(Path, Maximum) :-
+  sla(Path, maximum_latency_ms, Maximum).
+
+status(Path, sla_compliant) :-
+  sla_compliant(Path).
+
+reason(Path, "path latency including jitter is below the SLA limit") :-
+  sla_compliant(Path).