eyelang 0.1.0

package/examples/hanoi.pl

@@ -0,0 +1,20 @@
+% Towers of Hanoi adapted from Eyeling hanoi.n3.
+% Output is the complete list of moves for size 3.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(answer, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+memoize(hanoi, 5).
+
+hanoi(0, _From, _To, _Via, []).
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+hanoi(N, From, To, Via, Moves) :-
+  gt(N, 0),
+  sub(N, 1, N1),
+  hanoi(N1, From, Via, To, Before),
+  hanoi(N1, Via, To, From, After),
+  append(Before, [[From, To]|After], Moves).
+
+answer(3, Moves) :-
+  hanoi(3, left, right, center, Moves).

package/examples/heat-loss.pl

@@ -0,0 +1,51 @@
+% Engineering example: one-dimensional conductive heat loss through a wall.
+%
+% Thermal resistance is L/(k*A), and heat loss is DeltaT/R.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(type, 2).
+materialize(temperatureDifference_K, 2).
+materialize(thermalResistance_K_W, 2).
+materialize(heatLoss_W, 2).
+materialize(status, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+wall(wall1, conductivity_W_mK, 0.8).
+wall(wall1, area_m2, 12.0).
+wall(wall1, thickness_m, 0.2).
+wall(wall1, indoor_C, 21.0).
+wall(wall1, outdoor_C, -4.0).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+temperature_difference(Wall, DeltaT) :-
+  wall(Wall, indoor_C, Indoor),
+  wall(Wall, outdoor_C, Outdoor),
+  sub(Indoor, Outdoor, DeltaT).
+
+thermal_resistance(Wall, Resistance) :-
+  wall(Wall, thickness_m, Thickness),
+  wall(Wall, conductivity_W_mK, Conductivity),
+  wall(Wall, area_m2, Area),
+  mul(Conductivity, Area, Conductance),
+  div(Thickness, Conductance, Resistance).
+
+heat_loss(Wall, HeatLoss) :-
+  temperature_difference(Wall, DeltaT),
+  thermal_resistance(Wall, Resistance),
+  div(DeltaT, Resistance, HeatLoss).
+
+type(Wall, conduction_heat_loss) :-
+  wall(Wall, thickness_m, _Thickness).
+
+temperatureDifference_K(Wall, DeltaT) :-
+  temperature_difference(Wall, DeltaT).
+
+thermalResistance_K_W(Wall, Resistance) :-
+  thermal_resistance(Wall, Resistance).
+
+heatLoss_W(Wall, HeatLoss) :-
+  heat_loss(Wall, HeatLoss).
+
+status(Wall, high_heat_loss) :-
+  heat_loss(Wall, HeatLoss),
+  gt(HeatLoss, 1000.0).

package/examples/heron-theorem.pl

@@ -0,0 +1,36 @@
+% Heron's theorem: area = sqrt(s(s-a)(s-b)(s-c)).
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(semiperimeter, 2).
+materialize(heronProduct, 2).
+materialize(area, 2).
+materialize(status, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+% 13-14-15 is a classic integer-sided triangle with area 84.
+triangle(field_plot, 13, 14, 15).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+semiperimeter(Triangle, S) :-
+  triangle(Triangle, A, B, C),
+  add(A, B, AB),
+  add(AB, C, Sum),
+  div(Sum, 2, S).
+
+% Area is obtained by taking the square root of this Heron product.
+heron_product(Triangle, Product) :-
+  triangle(Triangle, A, B, C),
+  semiperimeter(Triangle, S),
+  sub(S, A, SA),
+  sub(S, B, SB),
+  sub(S, C, SC),
+  mul(S, SA, T1),
+  mul(T1, SB, T2),
+  mul(T2, SC, Product).
+
+area(Triangle, Area) :-
+  heron_product(Triangle, Product),
+  pow(Product, 0.5, Area).
+
+heronProduct(Triangle, P) :- heron_product(Triangle, P).
+status(Triangle, valid_survey_triangle) :- area(Triangle, A), gt(A, 0).

package/examples/ideal-gas-law.pl

@@ -0,0 +1,37 @@
+% Science example: ideal gas law.
+%
+% A simple gas cell uses P*V = n*R*T.  The constants are chosen so that the
+% computed pressure is exactly near one atmosphere in this small example.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(pressure_Pa, 2).
+materialize(status, 2).
+materialize(reason, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+gas_cell(cell1, 1.0, 8.0, 300.0, 0.024).
+pressure_limit(cell1, low_Pa, 95000.0).
+pressure_limit(cell1, high_Pa, 105000.0).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+pressure(Cell, Pressure) :-
+  gas_cell(Cell, Moles, GasConstant, Temperature, Volume),
+  mul(Moles, GasConstant, NR),
+  mul(NR, Temperature, NRT),
+  div(NRT, Volume, Pressure).
+
+near_atmospheric(Cell) :-
+  pressure(Cell, Pressure),
+  pressure_limit(Cell, low_Pa, Low),
+  pressure_limit(Cell, high_Pa, High),
+  gt(Pressure, Low),
+  lt(Pressure, High).
+
+pressure_Pa(Cell, Pressure) :-
+  pressure(Cell, Pressure).
+
+status(Cell, near_atmospheric) :-
+  near_atmospheric(Cell).
+
+reason(Cell, "pressure is inside the one-atmosphere tolerance band") :-
+  near_atmospheric(Cell).

package/examples/illegitimate-reasoning.pl

@@ -0,0 +1,88 @@
+% Illegitimate reasoning detector.
+%
+% The input facts describe arguments and their surface reasoning pattern. Helper
+% predicates identify common invalid inference forms. The output layer emits only
+% concise report relations: the argument is illegitimate, which fallacy was found,
+% the challenged conclusion, and a short reason why.
+
+% Affirming the consequent:
+%   If it rained, the street is wet. The street is wet. Therefore it rained.
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(type, 2).
+materialize(fallacy, 2).
+materialize(conclusion, 2).
+materialize(reason, 2).
+materialize(sampleSize, 2).
+materialize(requiredSampleSize, 2).
+materialize(omittedAlternative, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+argument(arg_affirming_consequent).
+implication(arg_affirming_consequent, rain, street_wet).
+observed(arg_affirming_consequent, street_wet).
+concludes(arg_affirming_consequent, rain).
+
+% Denying the antecedent:
+%   If the key is present, the door opens. The key is not present. Therefore the door does not open.
+argument(arg_denying_antecedent).
+implication(arg_denying_antecedent, key_present, door_opens).
+observed(arg_denying_antecedent, neg(key_present)).
+concludes(arg_denying_antecedent, neg(door_opens)).
+
+% Hasty generalization:
+%   Three sampled cases are treated as enough for a universal conclusion.
+argument(arg_hasty_generalization).
+sample_size(arg_hasty_generalization, 3).
+required_sample_size(arg_hasty_generalization, 30).
+concludes(arg_hasty_generalization, all(crows, black)).
+
+% False dilemma:
+%   Only two choices are presented even though a relevant third option exists.
+argument(arg_false_dilemma).
+presented_alternatives(arg_false_dilemma, [approve_now, reject_forever]).
+omitted_alternative(arg_false_dilemma, revise_proposal).
+concludes(arg_false_dilemma, approve_now).
+
+% A contrast case: modus ponens is not flagged.
+argument(arg_modus_ponens).
+implication(arg_modus_ponens, subscription_paid, access_allowed).
+observed(arg_modus_ponens, subscription_paid).
+concludes(arg_modus_ponens, access_allowed).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+fallacy(A, affirming_consequent) :-
+  argument(A),
+  implication(A, Antecedent, Consequent),
+  observed(A, Consequent),
+  concludes(A, Antecedent).
+
+fallacy(A, denying_antecedent) :-
+  argument(A),
+  implication(A, Antecedent, Consequent),
+  observed(A, neg(Antecedent)),
+  concludes(A, neg(Consequent)).
+
+fallacy(A, hasty_generalization) :-
+  argument(A),
+  sample_size(A, N),
+  required_sample_size(A, Min),
+  lt(N, Min),
+  concludes(A, all(_, _)).
+
+fallacy(A, false_dilemma) :-
+  argument(A),
+  presented_alternatives(A, _),
+  omitted_alternative(A, _),
+  concludes(A, _).
+
+reason(arg_affirming_consequent, "observing the consequent does not prove the antecedent").
+reason(arg_denying_antecedent, "denying the antecedent does not disprove the consequent").
+reason(arg_hasty_generalization, "sample size is below the threshold for a universal conclusion").
+reason(arg_false_dilemma, "a relevant alternative is omitted").
+
+type(A, illegitimate_reasoning) :- fallacy(A, _).
+conclusion(A, C) :- fallacy(A, _), concludes(A, C).
+reason(A, R) :- fallacy(A, _), reason(A, R).
+sampleSize(A, N) :- fallacy(A, hasty_generalization), sample_size(A, N).
+requiredSampleSize(A, Min) :- fallacy(A, hasty_generalization), required_sample_size(A, Min).
+omittedAlternative(A, Alt) :- fallacy(A, false_dilemma), omitted_alternative(A, Alt).

package/examples/knowledge-engineering-alignment-flow.pl

@@ -0,0 +1,40 @@
+% Knowledge-engineering alignment flow in eyelang.
+% Local source predicates are aligned once and then reused to produce a target-shaped flow view.
+% fpv_* atoms denote a tiny local Flow/Policy Vocabulary profile.
+
+materialize(type, 2).
+materialize(target_fact, 3).
+materialize(runtime_rule, 2).
+materialize(target_predicate, 2).
+materialize(flow_emits, 2).
+materialize(trusted_by, 2).
+
+sub_class(local_observation, sosa_observation).
+sub_class(temperature_probe, sosa_sensor).
+sub_property(observed_by, sosa_madeBySensor).
+sub_property(observed_at, sosa_resultTime).
+sub_property(temperature_celsius, sosa_hasSimpleResult).
+sub_property(in_flow, fpv_hasFlowStep).
+equivalent_property(observed_feature, sosa_hasFeatureOfInterest).
+
+type(msg1, local_observation).
+type(probe7, temperature_probe).
+triple(msg1, observed_by, probe7).
+triple(msg1, observed_at, "2026-06-17T12:34:56Z").
+triple(msg1, temperature_celsius, 18.6).
+triple(msg1, observed_feature, platform_b).
+triple(msg1, in_flow, ingest_step).
+
+% Generic alignment rules.
+type(Thing, Super) :- type(Thing, Class), sub_class(Class, Super).
+target_fact(Subject, SuperPredicate, Object) :- triple(Subject, Predicate, Object), sub_property(Predicate, SuperPredicate).
+target_fact(Subject, TargetPredicate, Object) :- triple(Subject, Predicate, Object), equivalent_property(Predicate, TargetPredicate).
+target_fact(Subject, SourcePredicate, Object) :- triple(Subject, Predicate, Object), equivalent_property(SourcePredicate, Predicate).
+
+runtime_rule(SourcePredicate, copy_to_target) :- sub_property(SourcePredicate, _TargetPredicate).
+runtime_rule(SourcePredicate, copy_to_target) :- equivalent_property(SourcePredicate, _TargetPredicate).
+target_predicate(SourcePredicate, TargetPredicate) :- sub_property(SourcePredicate, TargetPredicate).
+target_predicate(SourcePredicate, TargetPredicate) :- equivalent_property(SourcePredicate, TargetPredicate).
+
+flow_emits(Step, Message) :- type(Message, sosa_observation), target_fact(Message, fpv_hasFlowStep, Step), target_fact(Message, sosa_madeBySensor, _Sensor).
+trusted_by(Step, Sensor) :- type(Message, sosa_observation), target_fact(Message, fpv_hasFlowStep, Step), target_fact(Message, sosa_madeBySensor, Sensor).

package/examples/law-of-cosines.pl

@@ -0,0 +1,31 @@
+% Law of cosines: c^2 = a^2 + b^2 - 2ab cos(C).
+% The example uses a 60-degree included angle, so cos(C) is represented as 0.5.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(sideCSquared, 2).
+materialize(sideC, 2).
+materialize(status, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+% Stored tuple is triangle(Name, sideA, sideB, cosIncludedAngle).
+triangle(tri60, 7, 9, 0.5).
+
+% Compute c^2 first so both squared and square-rooted outputs can be shown.
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+side_c_squared(Triangle, C2) :-
+  triangle(Triangle, A, B, CosC),
+  mul(A, A, A2),
+  mul(B, B, B2),
+  add(A2, B2, Sum),
+  mul(2, A, TwoA),
+  mul(TwoA, B, TwoAB),
+  mul(TwoAB, CosC, Projection),
+  sub(Sum, Projection, C2).
+
+side_c(Triangle, C) :-
+  side_c_squared(Triangle, C2),
+  pow(C2, 0.5, C).
+
+sideCSquared(Triangle, C2) :- side_c_squared(Triangle, C2).
+sideC(Triangle, C) :- side_c(Triangle, C).
+status(Triangle, acute_triangle) :- side_c_squared(Triangle, C2), gt(C2, 0).

package/examples/least-squares-regression.pl

@@ -0,0 +1,81 @@
+% 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.
+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([], 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/list-collection.pl

@@ -0,0 +1,33 @@
+% 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).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+% Lists are first-class terms in facts and rule heads/bodies.
+collection(numbers, [1, 2, 3]).
+collection(letters, [a, b]).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+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

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