seam-lang 2.0.0

package/examples/hamming-code.pl

@@ -0,0 +1,109 @@
+% 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

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

@@ -0,0 +1,56 @@
+% 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/herbrand-witnesses.pl

@@ -0,0 +1,31 @@
+% Existential-style consequences as explicit Herbrand witness terms.
+%
+% Seam has no blank nodes and no existential variables in rule heads.  The
+% practical executable form is to put a named functional term directly in the
+% rule head.  The term is ordinary data: stable, visible, and proof-friendly.
+
+materialize(has_parent, 2).
+materialize(registration, 3).
+materialize(same_witness, 2).
+materialize(distinct_witnesses, 2).
+
+person(alice).
+person(bob).
+
+takes(alice, logic).
+takes(alice, math).
+takes(bob, logic).
+
+% One variable: every person has a deterministic parent witness.
+has_parent(Child, parent_of(Child)) :-
+  person(Child).
+
+% Two variables: every student/course pair has its own registration witness.
+registration(Student, Course, registration_of(Student, Course)) :-
+  takes(Student, Course).
+
+same_witness(parent_of_alice, true) :-
+  eq(parent_of(alice), parent_of(alice)).
+
+distinct_witnesses(alice_logic_vs_alice_math, true) :-
+  neq(registration_of(alice, logic), registration_of(alice, math)).

package/examples/heron-theorem.pl

@@ -0,0 +1,42 @@
+% 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

@@ -0,0 +1,39 @@
+% 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

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

@@ -0,0 +1,35 @@
+% Integer partition counts by tabled 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).
+
+table(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

@@ -0,0 +1,69 @@
+% 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).
+
+table(leq, 2).
+table(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

@@ -0,0 +1,48 @@
+% 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

@@ -0,0 +1,46 @@
+% 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

@@ -0,0 +1,46 @@
+% Knowledge-engineering alignment flow in Seam.
+%
+% 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).