eyelang 1.6.0 → 1.7.0

package/examples/lldm.pl

@@ -1,78 +0,0 @@
-% 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/manufacturing-quality-control.pl

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

package/examples/microgrid-dispatch.pl

@@ -1,85 +0,0 @@
-% 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/monkey-bananas.pl

@@ -1,45 +0,0 @@
-% 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/n-queens.pl

@@ -1,23 +0,0 @@
-% 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/n3-builtins.n3

@@ -1,28 +0,0 @@
-@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/network-sla.pl

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