eyelang 1.2.2 → 1.3.1

package/examples/hamming-code.pl

@@ -1,109 +0,0 @@
-% Technology example: Hamming(7,4) single-bit error correction.
-%
-% The received word has one corrupted bit. Syndrome bits identify the bad
-% position, then the corrected codeword and decoded payload are derived.
-
-% Output declarations: materialize/2 selects the relations written to this example's golden output.
-%
-% Positions are one-based to match the textbook parity-check layout. The
-% syndrome value is both the error certificate and the index of the bit to fix.
-materialize(syndrome, 2).
-materialize(errorBit, 2).
-materialize(correctedCodeword, 2).
-materialize(decodedPayload, 2).
-materialize(status, 2).
-materialize(reason, 2).
-
-% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
-received_bit(packet1, 1, 1).
-received_bit(packet1, 2, 0).
-received_bit(packet1, 3, 1).
-received_bit(packet1, 4, 1).
-received_bit(packet1, 5, 1).
-received_bit(packet1, 6, 1).
-received_bit(packet1, 7, 0).
-
-flip(0, 1).
-flip(1, 0).
-
-% Derivation rules: each rule below contributes one logical step toward the displayed results.
-parity4(A, B, C, D, Parity) :-
-  add(A, B, AB),
-  add(AB, C, ABC),
-  add(ABC, D, Sum),
-  mod(Sum, 2, Parity).
-
-syndrome_bit1(Code, S1) :-
-  received_bit(Code, 1, B1),
-  received_bit(Code, 3, B3),
-  received_bit(Code, 5, B5),
-  received_bit(Code, 7, B7),
-  parity4(B1, B3, B5, B7, S1).
-
-syndrome_bit2(Code, S2) :-
-  received_bit(Code, 2, B2),
-  received_bit(Code, 3, B3),
-  received_bit(Code, 6, B6),
-  received_bit(Code, 7, B7),
-  parity4(B2, B3, B6, B7, S2).
-
-syndrome_bit4(Code, S4) :-
-  received_bit(Code, 4, B4),
-  received_bit(Code, 5, B5),
-  received_bit(Code, 6, B6),
-  received_bit(Code, 7, B7),
-  parity4(B4, B5, B6, B7, S4).
-
-% syndrome/2 combines parity checks as S1 + 2*S2 + 4*S4.
-syndrome(Code, Syndrome) :-
-  syndrome_bit1(Code, S1),
-  syndrome_bit2(Code, S2),
-  syndrome_bit4(Code, S4),
-  mul(S2, 2, WeightedS2),
-  mul(S4, 4, WeightedS4),
-  add(S1, WeightedS2, Partial),
-  add(Partial, WeightedS4, Syndrome).
-
-corrected_bit(Code, Position, Corrected) :-
-  syndrome(Code, Position),
-  received_bit(Code, Position, Bit),
-  flip(Bit, Corrected).
-
-corrected_bit(Code, Position, Bit) :-
-  syndrome(Code, ErrorPosition),
-  neq(Position, ErrorPosition),
-  received_bit(Code, Position, Bit).
-
-corrected_codeword(Code, [B1, B2, B3, B4, B5, B6, B7]) :-
-  corrected_bit(Code, 1, B1),
-  corrected_bit(Code, 2, B2),
-  corrected_bit(Code, 3, B3),
-  corrected_bit(Code, 4, B4),
-  corrected_bit(Code, 5, B5),
-  corrected_bit(Code, 6, B6),
-  corrected_bit(Code, 7, B7).
-
-decoded_payload(Code, [D1, D2, D3, D4]) :-
-  corrected_bit(Code, 3, D1),
-  corrected_bit(Code, 5, D2),
-  corrected_bit(Code, 6, D3),
-  corrected_bit(Code, 7, D4).
-
-
-errorBit(Code, Position) :-
-  syndrome(Code, Position),
-  gt(Position, 0).
-
-correctedCodeword(Code, Codeword) :-
-  corrected_codeword(Code, Codeword).
-
-decodedPayload(Code, Payload) :-
-  decoded_payload(Code, Payload).
-
-status(Code, single_bit_corrected) :-
-  syndrome(Code, Position),
-  gt(Position, 0).
-
-reason(Code, "Hamming syndrome identifies the flipped bit position") :-
-  syndrome(Code, Position),
-  gt(Position, 0).

package/examples/hanoi.pl

@@ -1,19 +0,0 @@
-% Towers of Hanoi adapted from Eyeling hanoi.n3.
-% hanoi/5 recursively builds the move list by moving N-1 disks aside, moving the
-% largest disk, then moving N-1 disks onto the target peg.  The size-3 answer is
-% small enough for a readable golden output while still exercising list append.
-
-materialize(answer, 2).
-
-memoize(hanoi, 5).
-
-hanoi(0, _From, _To, _Via, []).
-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

@@ -1,56 +0,0 @@
-% Engineering example: one-dimensional conductive heat loss through a wall.
-%
-% Thermal resistance is L/(k*A), and heat loss is DeltaT/R.  The facts store wall
-% properties as a small attribute table, while rules derive temperature
-% difference, resistance, heat loss, and a qualitative status.
-%
-% Keeping each physical quantity as its own relation makes the proof explanation
-% read like a worked calculation.
-materialize(type, 2).
-materialize(temperatureDifference_K, 2).
-materialize(thermalResistance_K_W, 2).
-materialize(heatLoss_W, 2).
-materialize(status, 2).
-
-% Wall properties are stored as key/value facts: conductivity, area, thickness,
-% and inside/outside temperatures.
-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).
-
-% The model first derives the temperature difference and thermal resistance,
-% then divides DeltaT by resistance to classify the heat loss.
-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

@@ -1,42 +0,0 @@
-% Heron's theorem: area = sqrt(s(s-a)(s-b)(s-c)).
-%
-% The sample is the classic 13-14-15 triangle, whose area is exactly 84.  The
-% program materializes the semiperimeter, Heron product, and final area so proof
-% output can be checked against the familiar hand calculation.
-%
-% This is a compact example of theorem-shaped arithmetic: facts name a geometric
-% object, reusable relations compute intermediates, and wrapper predicates choose
-% the report vocabulary.
-materialize(semiperimeter, 2).
-materialize(heronProduct, 2).
-materialize(area, 2).
-materialize(status, 2).
-
-% A single survey triangle is enough to demonstrate the formula; 13-14-15 has
-% integer area 84, which makes the computed result easy to check.
-triangle(field_plot, 13, 14, 15).
-
-% semiperimeter/2 is the reusable first step in Heron's formula.
-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

@@ -1,39 +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).
-
-% gas_cell/5 records n, R, T, and V; pressure_limit/3 gives the tolerance band
-% used to classify the result as near atmospheric.
-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).
-
-% pressure/2 computes nRT/V in three explicit arithmetic steps so the proof
-% output exposes numerator construction and final division.
-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

@@ -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/integer-partitions.pl

@@ -1,35 +0,0 @@
-% Integer partition counts by memoized dynamic programming.
-%
-% partitions(N, K, Count) counts unordered sums of N using parts no larger than K.
-% The two recursive branches are the standard include-K / exclude-K split.  Without
-% memoization the same (N,K) subproblems are reached many times.
-materialize(partition_answer, 2).
-
-memoize(partitions, 3).
-
-% One empty sum partitions zero; positive N with K=0 is impossible.
-partitions(0, _K, 1).
-partitions(N, 0, 0) :- gt(N, 0).
-partitions(N, K, Count) :-
-  gt(N, 0),
-  gt(K, 0),
-  gt(K, N),
-  sub(K, 1, K1),
-  partitions(N, K1, Count).
-partitions(N, K, Count) :-
-  gt(N, 0),
-  gt(K, 0),
-  le(K, N),
-  sub(N, K, Remainder),
-  partitions(Remainder, K, WithK),
-  sub(K, 1, K1),
-  partitions(N, K1, WithoutK),
-  add(WithK, WithoutK, Count).
-
-% The ordinary partition number p(N) allows all parts up to N.
-partition_count(N, Count) :- partitions(N, N, Count).
-
-partition_answer(p_12, Count) :- partition_count(12, Count).
-partition_answer(p_15, Count) :- partition_count(15, Count).
-partition_answer(p_16_using_parts_at_most_5, Count) :- partitions(16, 5, Count).
-partition_answer(cumulative_p_1_to_8, Sum) :- sumall(C, (between(1, 8, N), partition_count(N, C)), Sum).

package/examples/intuitionistic-logic-kripke.pl

@@ -1,69 +0,0 @@
-% Intuitionistic logic emulation with a finite Kripke model.
-%
-% The preorder leq/2 represents information growth: later worlds contain at
-% least as much information as earlier worlds.  Atomic facts persist upward, and
-% implication is checked at every future world.  This lets the example show a
-% constructive implication that holds while excluded middle is not forced at the
-% root world.
-materialize(intuitionistic_truth, 3).
-materialize(intuitionistic_countermodel, 3).
-
-memoize(leq, 2).
-memoize(forces, 2).
-
-world(root).
-world(left).
-world(right).
-world(both).
-
-step(root, left).
-step(root, right).
-step(left, both).
-step(right, both).
-
-base(left, p).
-base(right, q).
-
-leq(World, World) :- world(World).
-leq(From, To) :- step(From, Mid), leq(Mid, To).
-
-% Upward persistence for atoms: if P becomes known at SomeWorld, every later
-% world also forces P.
-forces(World, atom(Prop)) :-
-  leq(SomeWorld, World),
-  base(SomeWorld, Prop).
-
-forces(World, and(Left, Right)) :-
-  forces(World, Left),
-  forces(World, Right).
-
-forces(World, or(Left, _Right)) :- forces(World, Left).
-forces(World, or(_Left, Right)) :- forces(World, Right).
-
-% A -> B holds at World when no future world has A without B.
-forces(World, implies(Left, Right)) :-
-  world(World),
-  not(bad_implication(World, Left, Right)).
-
-forces(World, neg(Formula)) :-
-  forces(World, implies(Formula, bottom)).
-
-bad_implication(World, Left, Right) :-
-  leq(World, Future),
-  forces(Future, Left),
-  not(forces(Future, Right)).
-
-intuitionistic_truth(monotone_p_reaches_both, both, atom(p)) :-
-  forces(both, atom(p)).
-
-intuitionistic_truth(constructive_case_analysis, root, implies(atom(p), or(atom(p), atom(q)))) :-
-  forces(root, implies(atom(p), or(atom(p), atom(q)))).
-
-intuitionistic_truth(double_negated_branch_information, root, neg(neg(or(atom(p), atom(q))))) :-
-  forces(root, neg(neg(or(atom(p), atom(q))))).
-
-intuitionistic_countermodel(root_does_not_decide_branch, root, or(atom(p), atom(q))) :-
-  not(forces(root, or(atom(p), atom(q)))).
-
-intuitionistic_countermodel(excluded_middle_not_forced, root, or(atom(p), neg(atom(p)))) :-
-  not(forces(root, or(atom(p), neg(atom(p))))).

package/examples/job-shop-scheduling.pl

@@ -1,48 +0,0 @@
-% Tiny job-shop scheduling benchmark.
-%
-% Three jobs each require one mill operation and one lathe operation, with fixed
-% within-job precedence constraints.  The solver enumerates bounded start times,
-% rejects machine overlaps, and uses aggregate_min/5 to keep the minimum makespan.
-materialize(job_shop_answer, 2).
-
-% Two operations on the same machine are compatible when either one finishes before the other starts.
-nonoverlap(_StartA, EndA, StartB, _EndB) :- le(EndA, StartB).
-nonoverlap(StartA, _EndA, _StartB, EndB) :- le(EndB, StartA).
-
-feasible_schedule(Makespan, [
-  op(j1_mill, J1MillStart, J1MillEnd),
-  op(j1_lathe, J1LatheStart, J1LatheEnd),
-  op(j2_lathe, J2LatheStart, J2LatheEnd),
-  op(j2_mill, J2MillStart, J2MillEnd),
-  op(j3_mill, J3MillStart, J3MillEnd),
-  op(j3_lathe, J3LatheStart, J3LatheEnd)
-]) :-
-  between(0, 6, J1MillStart), add(J1MillStart, 3, J1MillEnd),
-  between(0, 6, J1LatheStart), add(J1LatheStart, 2, J1LatheEnd),
-  le(J1MillEnd, J1LatheStart),
-
-  between(0, 6, J2LatheStart), add(J2LatheStart, 2, J2LatheEnd),
-  between(0, 6, J2MillStart), add(J2MillStart, 4, J2MillEnd),
-  le(J2LatheEnd, J2MillStart),
-
-  between(0, 6, J3MillStart), add(J3MillStart, 2, J3MillEnd),
-  between(0, 6, J3LatheStart), add(J3LatheStart, 3, J3LatheEnd),
-  le(J3MillEnd, J3LatheStart),
-
-  nonoverlap(J1MillStart, J1MillEnd, J2MillStart, J2MillEnd),
-  nonoverlap(J1MillStart, J1MillEnd, J3MillStart, J3MillEnd),
-  nonoverlap(J2MillStart, J2MillEnd, J3MillStart, J3MillEnd),
-  nonoverlap(J1LatheStart, J1LatheEnd, J2LatheStart, J2LatheEnd),
-  nonoverlap(J1LatheStart, J1LatheEnd, J3LatheStart, J3LatheEnd),
-  nonoverlap(J2LatheStart, J2LatheEnd, J3LatheStart, J3LatheEnd),
-
-  max(J1LatheEnd, J2MillEnd, PartialMakespan),
-  max(PartialMakespan, J3LatheEnd, Makespan).
-
-% aggregate_min/5 returns both the best makespan and the schedule that achieved it.
-best_schedule(Makespan, Schedule) :-
-  aggregate_min(Makespan, Schedule, feasible_schedule(Makespan, Schedule), Makespan, Schedule).
-
-job_shop_answer(best_makespan, Makespan) :- best_schedule(Makespan, _Schedule).
-job_shop_answer(best_schedule, Schedule) :- best_schedule(_Makespan, Schedule).
-job_shop_answer(feasible_schedule_count, Count) :- countall(feasible_schedule(_Makespan, _Schedule), Count).

package/examples/knapsack-optimization.pl

@@ -1,46 +0,0 @@
-% 0/1 knapsack optimization with aggregate_max/5.
-%
-% subset/2 enumerates candidate expedition packs; total_weight/2 and total_value/2
-% score each pack.  feasible_pack/3 applies the capacity limit, and best_pack/3
-% keeps the highest-value feasible choice together with its weight.
-materialize(knapsack_answer, 2).
-
-% Capacity and item table are separated from the optimization rule for easy tuning.
-capacity(15).
-items([atlas, battery, camera, drone, emergency_radio, field_laptop, medkit, sensor]).
-
-item(atlas, 2, 6).
-item(battery, 4, 10).
-item(camera, 3, 8).
-item(drone, 6, 13).
-item(emergency_radio, 5, 11).
-item(field_laptop, 7, 16).
-item(medkit, 4, 9).
-item(sensor, 2, 7).
-
-% The include/exclude subset generator explores every 0/1 choice once.
-subset([], []).
-subset([Item|Rest], [Item|Chosen]) :- subset(Rest, Chosen).
-subset([_Item|Rest], Chosen) :- subset(Rest, Chosen).
-
-item_weight(Item, Weight) :- item(Item, Weight, _Value).
-item_value(Item, Value) :- item(Item, _Weight, Value).
-
-total_weight(Items, Weight) :- findall(W, (member(Item, Items), item_weight(Item, W)), Weights), sum_list(Weights, Weight).
-total_value(Items, Value) :- findall(V, (member(Item, Items), item_value(Item, V)), Values), sum_list(Values, Value).
-
-feasible_pack(Pack, Weight, Value) :-
-  items(All),
-  subset(All, Pack),
-  total_weight(Pack, Weight),
-  capacity(Capacity),
-  le(Weight, Capacity),
-  total_value(Pack, Value).
-
-best_pack(Pack, Weight, Value) :-
-  aggregate_max(Value, pack(Pack, Weight), feasible_pack(Pack, Weight, Value), Value, pack(Pack, Weight)).
-
-knapsack_answer(best_pack, Pack) :- best_pack(Pack, _Weight, _Value).
-knapsack_answer(total_weight, Weight) :- best_pack(_Pack, Weight, _Value).
-knapsack_answer(total_value, Value) :- best_pack(_Pack, _Weight, Value).
-knapsack_answer(feasible_pack_count, Count) :- countall(feasible_pack(_Pack, _Weight, _Value), Count).

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

@@ -1,46 +0,0 @@
-% Knowledge-engineering alignment flow in Eyelang.
-%
-% The source graph uses local observation predicates.  The mapping facts below
-% align those local names with small SOSA-like and FPV-like vocabulary atoms, then
-% generic rules emit a target-shaped flow view.
-%
-% This demonstrates a common knowledge-engineering pattern: keep source data in
-% its original shape, describe the alignment declaratively, and derive target facts
-% without rewriting the original assertions.
-
-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

@@ -1,37 +0,0 @@
-% Law of cosines: c^2 = a^2 + b^2 - 2ab cos(C).
-%
-% This pure-geometry example keeps trigonometry outside the language by storing
-% cos(C) as data.  Eyelang then performs the algebraic part of the theorem with
-% ordinary arithmetic predicates and materializes both c^2 and c.
-%
-% The 60-degree sample uses cos(C) = 0.5, so the proof shows each intermediate
-% numeric step rather than hiding the computation in one builtin.
-materialize(sideCSquared, 2).
-materialize(sideC, 2).
-materialize(status, 2).
-
-% The triangle fact stores the two known sides and the cosine of the included
-% angle.  Storing cos(C) directly avoids needing trigonometric built-ins while
-% still demonstrating the geometric formula.
-triangle(tri60, 7, 9, 0.5).
-
-% Compute c^2 first so both squared and square-rooted outputs can be shown.
-% side_c_squared/2 follows the law of cosines step by step, then side_c/2
-% takes the square root for the reported side length.
-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).