eyelang 1.2.2 → 1.3.1

package/examples/least-squares-regression.eye

@@ -0,0 +1,85 @@
+% 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.eye

@@ -0,0 +1,51 @@
+% 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.eye

@@ -0,0 +1,35 @@
+% 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.eye

@@ -0,0 +1,80 @@
+% 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.eye

@@ -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/matrix-chain-order.eye

@@ -0,0 +1,79 @@
+% Matrix-chain multiplication order by tabled 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).
+
+table(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.eye

@@ -0,0 +1,89 @@
+% 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.eye

@@ -0,0 +1,53 @@
+% 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.eye

@@ -0,0 +1,45 @@
+% 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.eye

@@ -0,0 +1,35 @@
+% 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).
+
+table(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.eye

@@ -0,0 +1,45 @@
+% Monkey and bananas planning problem, adapted from Eyelet's
+% input/monkey-bananas.eye.
+%
+% 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.
+table(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).