eyeling 1.34.4 → 1.34.6

package/examples/eyelang/hanoi.pl

@@ -1,20 +0,0 @@
-% 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/eyelang/heat-loss.pl

@@ -1,51 +0,0 @@
-% 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/eyelang/heron-theorem.pl

@@ -1,36 +0,0 @@
-% 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/eyelang/ideal-gas-law.pl

@@ -1,37 +0,0 @@
-% 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/eyelang/illegitimate-reasoning.pl

@@ -1,88 +0,0 @@
-% 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/eyelang/knowledge-engineering-alignment-flow.pl

@@ -1,40 +0,0 @@
-% 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/eyelang/law-of-cosines.pl

@@ -1,31 +0,0 @@
-% 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/eyelang/least-squares-regression.pl

@@ -1,81 +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.
-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/eyelang/list-collection.pl

@@ -1,33 +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).
-
-% 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/eyelang/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/eyelang/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/eyelang/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).