eyelang 1.2.2 → 1.3.1

package/examples/least-squares-regression.pl

@@ -1,85 +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.
-%
-% Accumulating sufficient statistics keeps the regression formulas compact and
-% makes the proof show the same intermediate values a hand calculation would use.
-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/7 folds points into N, Σx, Σy, Σx², Σxy, and Σy².
-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/linear-logic-resources.pl

@@ -1,51 +0,0 @@
-% Linear logic emulation with explicit consumable resources.
-%
-% Eyelang predicates are reusable Horn clauses, so this example represents the
-% linear part explicitly as a multiset-like state list.  A rule consumes its
-% input resources with select/3 and produces a new state.  If a resource is not
-% present, the step fails, which models the “use exactly once” discipline of
-% linear implication.
-%
-% The successful plan turns wheat, yeast, and heat into bread.  The rejected
-% double-spend check shows that one coin cannot be consumed by two purchases.
-materialize(linear_result, 3).
-materialize(linear_check, 2).
-
-initial(kitchen, [wheat, yeast, heat]).
-initial(wallet, [coin]).
-
-% linear_rule(Name, Inputs, Outputs) is an encoded linear implication:
-% Inputs -o Outputs, evaluated against the current resource state.
-linear_rule(mill, [wheat], [flour]).
-linear_rule(mix, [flour, yeast], [dough]).
-linear_rule(bake, [dough, heat], [bread]).
-linear_rule(buy_flour, [coin], [flour]).
-linear_rule(buy_yeast, [coin], [yeast]).
-
-% consume_all/3 removes each required resource once.  This is the key linear
-% operation: a second attempt to use the same token cannot succeed.
-consume_all([], State, State).
-consume_all([Need | Needs], State0, State2) :-
-  select(Need, State0, State1),
-  consume_all(Needs, State1, State2).
-
-linear_step(State0, Rule, State2) :-
-  linear_rule(Rule, Inputs, Outputs),
-  consume_all(Inputs, State0, Rest),
-  append(Outputs, Rest, State2).
-
-run_linear(0, State, [], State).
-run_linear(Steps, State0, [Rule | Plan], State2) :-
-  gt(Steps, 0),
-  linear_step(State0, Rule, State1),
-  sub(Steps, 1, Remaining),
-  run_linear(Remaining, State1, Plan, State2).
-
-linear_result(kitchen, Plan, FinalState) :-
-  initial(kitchen, State),
-  run_linear(3, State, Plan, FinalState),
-  eq(FinalState, [bread]).
-
-linear_check(double_spend_rejected, yes) :-
-  initial(wallet, State),
-  not(run_linear(2, State, [buy_flour, buy_yeast], _FinalState)).

package/examples/list-collection.pl

@@ -1,35 +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).
-
-% The collection/2 facts keep complete lists as first-class terms rather than
-% expanding them into separate item facts.
-% Lists are first-class terms in facts and rule heads/bodies.
-collection(numbers, [1, 2, 3]).
-collection(letters, [a, b]).
-
-% The derived predicates show list length, membership, append, and pattern
-% matching with [Head|Tail] in the smallest possible setting.
-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]).

package/examples/lldm.pl

@@ -1,80 +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).
-
-% val/3 stores raw landmark coordinates, derived deltas, line coefficients,
-% projected landmarks, lengths, and alarm values in one measurement namespace.
-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
-% The geometry rules build from coordinate differences to projected knee points,
-% then compute left/right leg lengths and compare the discrepancy with a threshold.
-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-chain-order.pl

@@ -1,79 +0,0 @@
-% Matrix-chain multiplication order by memoized interval dynamic programming.
-%
-% cost(I, J, Cost) is the minimum scalar multiplication cost for matrices I..J.
-% best_split/3 records which split obtains that cost, and parenthesization/3
-% reconstructs one optimal multiplication tree.
-materialize(matrix_chain_answer, 2).
-
-memoize(cost, 3).
-
-% Matrix dimensions are stored as adjacent p-values: matrix I has dimensions P_{I-1} x P_I.
-
-% Dimensions for the CLRS-style chain: A1 is 30x35, A2 is 35x15, and so on.
-% The dim/2 facts store boundary dimensions, so multiplying Ai..Ak by A(k+1)..Aj
-% costs dim(I-1) * dim(K) * dim(J).
-dim(0, 30).
-dim(1, 35).
-dim(2, 15).
-dim(3, 5).
-dim(4, 10).
-dim(5, 20).
-dim(6, 25).
-
-matrix_count(6).
-
-cost(I, I, 0) :- matrix_count(N), between(1, N, I).
-cost(I, J, Cost) :-
-  lt(I, J),
-  aggregate_min(SplitCost, K,
-    (between(I, J, K),
-     lt(K, J),
-     cost(I, K, Left),
-     add(K, 1, K1),
-     cost(K1, J, Right),
-     sub(I, 1, I0),
-     dim(I0, Rows),
-     dim(K, Shared),
-     dim(J, Cols),
-     mul(Rows, Shared, First),
-     mul(First, Cols, MultCost),
-     add(Left, Right, Partial),
-     add(Partial, MultCost, SplitCost)),
-    Cost, _BestK).
-
-best_split(I, J, K) :-
-  lt(I, J),
-  aggregate_min(SplitCost, K,
-    (between(I, J, K),
-     lt(K, J),
-     cost(I, K, Left),
-     add(K, 1, K1),
-     cost(K1, J, Right),
-     sub(I, 1, I0),
-     dim(I0, Rows),
-     dim(K, Shared),
-     dim(J, Cols),
-     mul(Rows, Shared, First),
-     mul(First, Cols, MultCost),
-     add(Left, Right, Partial),
-     add(Partial, MultCost, SplitCost)),
-    _Cost, K).
-
-parenthesization(I, I, matrix(I)).
-parenthesization(I, J, product(LeftTree, RightTree)) :-
-  lt(I, J),
-  best_split(I, J, K),
-  add(K, 1, K1),
-  parenthesization(I, K, LeftTree),
-  parenthesization(K1, J, RightTree).
-
-matrix_chain_answer(min_cost, Cost) :- cost(1, 6, Cost).
-matrix_chain_answer(best_split_1_6, K) :- best_split(1, 6, K).
-matrix_chain_answer(best_order, Tree) :- parenthesization(1, 6, Tree).
-subproblem(I, J, Cost) :-
-  matrix_count(N),
-  between(1, N, I),
-  between(I, N, J),
-  cost(I, J, Cost).
-
-matrix_chain_answer(subproblem_count, Count) :- countall(subproblem(_I, _J, _Cost), Count).

package/examples/microgrid-dispatch.pl

@@ -1,89 +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.
-%
-% The dispatch policy is greedy but auditable: use renewables first, discharge
-% the battery only down to reserve, then import the remaining deficit from grid.
-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/1 passes only when contract and reserve constraints remain satisfied.
-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/missionaries-cannibals.pl

@@ -1,53 +0,0 @@
-% Missionaries-and-cannibals river crossing as guarded state-space search.
-%
-% A state records missionaries and cannibals on the left bank plus the boat side.
-% crossing/3 applies one legal boat load and state_safe/1 checks both banks.
-% journey/4 carries a visited list to avoid loops in the finite state graph.
-materialize(missionaries_cannibals_answer, 2).
-
-% Boat loads: one or two passengers, with at least one passenger per crossing.
-move(1, 0).
-move(0, 1).
-move(2, 0).
-move(0, 2).
-move(1, 1).
-
-% A bank is safe if there are no missionaries or missionaries are not outnumbered.
-bank_safe(0, _C).
-bank_safe(M, C) :- gt(M, 0), ge(M, C).
-
-state_safe(state(MLeft, CLeft, _Boat)) :-
-  between(0, 3, MLeft),
-  between(0, 3, CLeft),
-  sub(3, MLeft, MRight),
-  sub(3, CLeft, CRight),
-  bank_safe(MLeft, CLeft),
-  bank_safe(MRight, CRight).
-
-crossing(state(MLeft, CLeft, left), state(NextM, NextC, right), carry(MoveM, MoveC)) :-
-  move(MoveM, MoveC),
-  sub(MLeft, MoveM, NextM),
-  sub(CLeft, MoveC, NextC),
-  state_safe(state(NextM, NextC, right)).
-crossing(state(MLeft, CLeft, right), state(NextM, NextC, left), carry(MoveM, MoveC)) :-
-  move(MoveM, MoveC),
-  add(MLeft, MoveM, NextM),
-  add(CLeft, MoveC, NextC),
-  state_safe(state(NextM, NextC, left)).
-
-journey(Goal, Goal, Visited, Visited).
-journey(State, Goal, Visited, Path) :-
-  crossing(State, Next, _Carry),
-  not_member(Next, Visited),
-  journey(Next, Goal, [Next|Visited], Path).
-
-solution(Path) :-
-  journey(state(3, 3, left), state(0, 0, right), [state(3, 3, left)], ReversePath),
-  reverse(ReversePath, Path).
-
-missionaries_cannibals_answer(first_solution, Path) :- once(solution(Path)).
-missionaries_cannibals_answer(state_count, Count) :- countall(state_safe(state(_M, _C, _Boat)), Count).
-missionaries_cannibals_answer(step_count, Steps) :-
-  once(solution(Path)),
-  length(Path, States),
-  sub(States, 1, Steps).

package/examples/modal-logic-kripke.pl

@@ -1,45 +0,0 @@
-% Modal logic emulation with a finite Kripke frame.
-%
-% Worlds and accessibility edges are ordinary facts.  mforces/2 interprets modal
-% formula terms such as box(clear) and diamond(repaired).  box(F) is true at a
-% world when every accessible world satisfies F; diamond(F) is true when at
-% least one accessible world satisfies F.
-materialize(modal_truth, 3).
-materialize(modal_countermodel, 2).
-
-world(w0).
-world(w1).
-world(w2).
-world(w3).
-
-accessible(w0, w1).
-accessible(w0, w2).
-accessible(w1, w1).
-accessible(w1, w3).
-accessible(w2, w2).
-accessible(w3, w3).
-
-true_at(w1, clear).
-true_at(w2, clear).
-true_at(w3, clear).
-true_at(w2, repaired).
-
-mforces(_World, top).
-mforces(World, atom(Prop)) :- true_at(World, Prop).
-mforces(World, and(Left, Right)) :- mforces(World, Left), mforces(World, Right).
-mforces(World, diamond(Formula)) :- accessible(World, Next), mforces(Next, Formula).
-mforces(World, box(Formula)) :-
-  world(World),
-  forall(accessible(World, Next), mforces(Next, Formula)).
-
-modal_truth(all_accessible_worlds_clear, w0, box(atom(clear))) :-
-  mforces(w0, box(atom(clear))).
-
-modal_truth(repair_is_possible, w0, diamond(atom(repaired))) :-
-  mforces(w0, diamond(atom(repaired))).
-
-modal_truth(nested_possibility, w1, diamond(and(atom(clear), atom(clear)))) :-
-  mforces(w1, diamond(and(atom(clear), atom(clear)))).
-
-modal_countermodel(repair_not_necessary, w0) :-
-  not(mforces(w0, box(atom(repaired)))).

package/examples/modular-exponentiation.pl

@@ -1,35 +0,0 @@
-% Modular exponentiation by repeated squaring.
-%
-% pow_mod(Base, Exp, Modulus, Result) uses the even/odd exponent split, giving
-% logarithmic-depth arithmetic.  Memoization matters when the same modular powers
-% are reused by Fermat-style congruence checks.
-materialize(modular_answer, 2).
-
-memoize(pow_mod, 4).
-
-% Base case: any nonzero base to exponent zero is 1 modulo Mod.
-pow_mod(_Base, 0, Mod, Result) :- mod(1, Mod, Result).
-pow_mod(Base, Exp, Modulus, Result) :-
-  gt(Exp, 0),
-  mod(Exp, 2, 0),
-  div(Exp, 2, Half),
-  pow_mod(Base, Half, Modulus, HalfPower),
-  mul(HalfPower, HalfPower, Square),
-  mod(Square, Modulus, Result).
-pow_mod(Base, Exp, Modulus, Result) :-
-  gt(Exp, 0),
-  mod(Exp, 2, 1),
-  sub(Exp, 1, EvenExp),
-  pow_mod(Base, EvenExp, Modulus, EvenPower),
-  mul(Base, EvenPower, Product),
-  mod(Product, Modulus, Result).
-
-% This is a Fermat congruence check, not a full primality proof.
-fermat_witness(Base, PrimeCandidate) :-
-  sub(PrimeCandidate, 1, Exponent),
-  pow_mod(Base, Exponent, PrimeCandidate, 1).
-
-modular_answer(pow_7_560_mod_561, R) :- pow_mod(7, 560, 561, R).
-modular_answer(pow_2_1000_mod_1009, R) :- pow_mod(2, 1000, 1009, R).
-modular_answer(fermat_2_101, true) :- fermat_witness(2, 101).
-modular_answer(fermat_3_101, true) :- fermat_witness(3, 101).

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).