seam-lang 2.0.0

package/examples/knuth-bendix-completion.pl

@@ -0,0 +1,55 @@
+% Bounded Knuth-Bendix-style completion for append/2 terms.
+%
+% Full Knuth-Bendix completion orients equations, generates all critical pairs,
+% reduces them, and may add new rules until all overlaps are joinable.  That is
+% a difficult global search problem.  This example keeps the recognizable shape
+% but bounds the hard part: the rewrite system is fixed, and a small catalog of
+% critical overlaps is checked for joinability by normalization.
+
+materialize(kbAnswer, 2).
+
+table(normal_form, 2).
+
+% Oriented equations for a monoid-like append constructor.
+%   append(nil, x)       -> x
+%   append(x, nil)       -> x
+%   append(append(x,y),z)-> append(x, append(y,z))
+% The third rule right-associates terms so normalization terminates here.
+oriented_rule(left_identity, append(nil, X), X).
+oriented_rule(right_identity, append(X, nil), X).
+oriented_rule(associate_right, append(append(X, Y), Z), append(X, append(Y, Z))).
+
+% One rewrite at the root or below an append node.
+rewrite_once(In, Out, Rule) :- oriented_rule(Rule, In, Out).
+rewrite_once(append(A, B), append(New_a, B), Rule) :- rewrite_once(A, New_a, Rule).
+rewrite_once(append(A, B), append(A, New_b), Rule) :- rewrite_once(B, New_b, Rule).
+
+% Normalization by repeated rewriting.  The rules above are oriented so that the
+% recursive search has a normal form for the bounded terms in this example.
+normal_form(Term, Term) :- not(rewrite_once(Term, _, _)).
+normal_form(Term, Normal) :- rewrite_once(Term, Next, _), normal_form(Next, Normal).
+
+% A few critical pairs that arise from overlapping the three oriented rules.
+% Each pair records the two one-step reducts that must later normalize together.
+critical_pair(left_identity_assoc,
+  append(a, b),
+  append(nil, append(a, b))).
+critical_pair(right_identity_assoc,
+  append(a, b),
+  append(a, append(nil, b))).
+critical_pair(nested_assoc,
+  append(append(a, append(b, c)), d),
+  append(append(a, b), append(c, d))).
+
+joined_pair(Name) :-
+  critical_pair(Name, Left, Right),
+  normal_form(Left, Normal),
+  normal_form(Right, Normal).
+
+sample_term(append(append(nil, append(a, nil)), append(b, c))).
+
+kbAnswer(sample_normal_form, Normal) :- sample_term(Term), normal_form(Term, Normal).
+kbAnswer(joined_critical_pair, Name) :- joined_pair(Name).
+kbAnswer(oriented_rule_count, Count) :- countall(oriented_rule(_, _, _), Count).
+kbAnswer(joined_critical_pair_count, Count) :- countall(joined_pair(_), Count).
+kbAnswer(note, "a bounded completion check proves the selected critical pairs join") :- joined_pair(nested_assoc).

package/examples/language.pl

@@ -0,0 +1,25 @@
+% Seam language-identity example.
+%
+% This file intentionally uses the modern Seam surface syntax:
+%   - `.pl` source files instead of Prolog `.pl` files
+%   - ISO Prolog-style uppercase variables
+%   - `table/2` for tabled recursive predicates
+%   - advisory `mode/3` and `semidet/2` declarations
+%   - quoted angle-bracket atoms for web-shaped identifiers
+%
+% The declarations below are ordinary facts as well as metadata for tooling.
+% They do not change the answers of the program.
+
+materialize(path, 2).
+
+table(path, 2).
+mode(edge, 2, [in, out]).
+mode(path, 2, [in, out]).
+semidet(edge, 2).
+
+edge('<urn:example:a>', '<urn:example:b>').
+edge('<urn:example:b>', '<urn:example:c>').
+edge('<urn:example:c>', '<urn:example:d>').
+
+path(X, Y) :- edge(X, Y).
+path(X, Z) :- edge(X, Y), path(Y, Z).

package/examples/law-of-cosines.pl

@@ -0,0 +1,37 @@
+% 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.  Seam 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).

package/examples/least-squares-regression.pl

@@ -0,0 +1,85 @@
+% Math example: least-squares linear regression.
+%
+% The rules reduce a list of points to sufficient statistics, then derive the
+% fitted slope, intercept, and coefficient of determination R^2.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+%
+% Accumulating sufficient statistics keeps the regression formulas compact and
+% makes the proof show the same intermediate values a hand calculation would use.
+materialize(slope, 2).
+materialize(intercept, 2).
+materialize(rSquared, 2).
+materialize(status, 2).
+materialize(reason, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+dataset(regression1, [point(1.0, 2.0), point(2.0, 3.0), point(3.0, 5.0), point(4.0, 4.0)]).
+threshold(regression1, minimum_r_squared, 0.60).
+
+% stats/7 folds points into N, Σx, Σy, Σx², Σxy, and Σy².
+stats([], 0.0, 0.0, 0.0, 0.0, 0.0, 0.0).
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+stats([point(X, Y)|Rest], N, Sumx, Sumy, Sumxx, Sumxy, Sumyy) :-
+  stats(Rest, N0, Sumx0, Sumy0, Sumxx0, Sumxy0, Sumyy0),
+  add(N0, 1.0, N),
+  add(Sumx0, X, Sumx),
+  add(Sumy0, Y, Sumy),
+  mul(X, X, Xx),
+  add(Sumxx0, Xx, Sumxx),
+  mul(X, Y, Xy),
+  add(Sumxy0, Xy, Sumxy),
+  mul(Y, Y, Yy),
+  add(Sumyy0, Yy, Sumyy).
+
+sufficient_statistics(Data, N, Sumx, Sumy, Sumxx, Sumxy, Sumyy) :-
+  dataset(Data, Points),
+  stats(Points, N, Sumx, Sumy, Sumxx, Sumxy, Sumyy).
+
+slope(Data, Slope) :-
+  sufficient_statistics(Data, N, Sumx, Sumy, Sumxx, Sumxy, _sumyy),
+  mul(N, Sumxy, Nsumxy),
+  mul(Sumx, Sumy, Sumxsumy),
+  sub(Nsumxy, Sumxsumy, Numerator),
+  mul(N, Sumxx, Nsumxx),
+  mul(Sumx, Sumx, Sumxsquared),
+  sub(Nsumxx, Sumxsquared, Denominator),
+  div(Numerator, Denominator, Slope).
+
+intercept(Data, Intercept) :-
+  sufficient_statistics(Data, N, Sumx, Sumy, _sumxx, _sumxy, _sumyy),
+  slope(Data, Slope),
+  mul(Slope, Sumx, Slopesumx),
+  sub(Sumy, Slopesumx, Numerator),
+  div(Numerator, N, Intercept).
+
+r_squared(Data, R2) :-
+  sufficient_statistics(Data, N, Sumx, Sumy, Sumxx, Sumxy, Sumyy),
+  mul(N, Sumxy, Nsumxy),
+  mul(Sumx, Sumy, Sumxsumy),
+  sub(Nsumxy, Sumxsumy, Numeratorbase),
+  pow(Numeratorbase, 2.0, Numerator),
+  mul(N, Sumxx, Nsumxx),
+  mul(Sumx, Sumx, Sumxsquared),
+  sub(Nsumxx, Sumxsquared, Xspread),
+  mul(N, Sumyy, Nsumyy),
+  mul(Sumy, Sumy, Sumysquared),
+  sub(Nsumyy, Sumysquared, Yspread),
+  mul(Xspread, Yspread, Denominator),
+  div(Numerator, Denominator, R2).
+
+accepted_fit(Data) :-
+  r_squared(Data, R2),
+  threshold(Data, minimum_r_squared, Minimum),
+  ge(R2, Minimum).
+
+
+
+rSquared(Data, R2) :-
+  r_squared(Data, R2).
+
+status(Data, accepted_linear_fit) :-
+  accepted_fit(Data).
+
+reason(Data, "R squared meets the minimum explanatory-power threshold") :-
+  accepted_fit(Data).

package/examples/linear-logic-resources.pl

@@ -0,0 +1,51 @@
+% Linear logic emulation with explicit consumable resources.
+%
+% Seam predicates are reusable Horn clauses, so this example represents the
+% linear part explicitly as a multiset-like state list.  A rule consumes its
+% input resources with select/3 and produces a new state.  If a resource is not
+% present, the step fails, which models the “use exactly once” discipline of
+% linear implication.
+%
+% The successful plan turns wheat, yeast, and heat into bread.  The rejected
+% double-spend check shows that one coin cannot be consumed by two purchases.
+materialize(linear_result, 3).
+materialize(linear_check, 2).
+
+initial(kitchen, [wheat, yeast, heat]).
+initial(wallet, [coin]).
+
+% linear_rule(Name, Inputs, Outputs) is an encoded linear implication:
+% Inputs -o Outputs, evaluated against the current resource state.
+linear_rule(mill, [wheat], [flour]).
+linear_rule(mix, [flour, yeast], [dough]).
+linear_rule(bake, [dough, heat], [bread]).
+linear_rule(buy_flour, [coin], [flour]).
+linear_rule(buy_yeast, [coin], [yeast]).
+
+% consume_all/3 removes each required resource once.  This is the key linear
+% operation: a second attempt to use the same token cannot succeed.
+consume_all([], State, State).
+consume_all([Need | Needs], State0, State2) :-
+  select(Need, State0, State1),
+  consume_all(Needs, State1, State2).
+
+linear_step(State0, Rule, State2) :-
+  linear_rule(Rule, Inputs, Outputs),
+  consume_all(Inputs, State0, Rest),
+  append(Outputs, Rest, State2).
+
+run_linear(0, State, [], State).
+run_linear(Steps, State0, [Rule | Plan], State2) :-
+  gt(Steps, 0),
+  linear_step(State0, Rule, State1),
+  sub(Steps, 1, Remaining),
+  run_linear(Remaining, State1, Plan, State2).
+
+linear_result(kitchen, Plan, Finalstate) :-
+  initial(kitchen, State),
+  run_linear(3, State, Plan, Finalstate),
+  eq(Finalstate, [bread]).
+
+linear_check(double_spend_rejected, yes) :-
+  initial(wallet, State),
+  not(run_linear(2, State, [buy_flour, buy_yeast], _finalstate)).

package/examples/list-collection.pl

@@ -0,0 +1,35 @@
+% List collections inspired by the Eyeling collection example.
+% Demonstrates list literals, member/2, length/2, append/3, and [Head|Tail].
+% Each materialized relation demonstrates one list operation.
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(length, 2).
+materialize(member, 2).
+materialize(append, 2).
+materialize(head, 2).
+materialize(tail, 2).
+
+% The collection/2 facts keep complete lists as first-class terms rather than
+% expanding them into separate item facts.
+% Lists are first-class terms in facts and rule heads/bodies.
+collection(numbers, [1, 2, 3]).
+collection(letters, [a, b]).
+
+% The derived predicates show list length, membership, append, and pattern
+% matching with [Head|Tail] in the smallest possible setting.
+length(numbers, N) :-
+  collection(numbers, List),
+  length(List, N).
+
+member(numbers, X) :-
+  collection(numbers, List),
+  member(X, List).
+
+append(letters, Extended) :-
+  collection(letters, List),
+  append(List, [c], Extended).
+
+head(letters, Head) :-
+  collection(letters, [Head|_tail]).
+
+tail(letters, Tail) :-
+  collection(letters, [_head|Tail]).

package/examples/lldm.pl

@@ -0,0 +1,80 @@
+% Leg Length Discrepancy Measurement, adapted from Eyeling lldm.n3.
+%
+% The measurement and intermediate geometry are kept in helper predicates so
+% the default relation materialization stays concise.  The visible output is
+% the alarm plus the small set of relations explaining why the alarm fired.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(type, 2).
+materialize(lld_left_length_cm, 2).
+materialize(lld_right_length_cm, 2).
+materialize(lld_discrepancy_cm, 2).
+materialize(lld_threshold_cm, 2).
+materialize(lld_reason, 2).
+
+% val/3 stores raw landmark coordinates, derived deltas, line coefficients,
+% projected landmarks, lengths, and alarm values in one measurement namespace.
+measurement(meas47).
+
+% measured landmark coordinates, in centimetres
+val(meas47, p1xCm, 10.1).
+val(meas47, p1yCm, 7.8).
+val(meas47, p2xCm, 45.1).
+val(meas47, p2yCm, 5.6).
+val(meas47, p3xCm, 3.6).
+val(meas47, p3yCm, 29.8).
+val(meas47, p4xCm, 54.7).
+val(meas47, p4yCm, 28.5).
+
+% threshold used by the alarm rule, in centimetres
+threshold(meas47, lld_alarm_threshold_cm, 1.25).
+
+% geometric intermediate values
+% The geometry rules build from coordinate differences to projected knee points,
+% then compute left/right leg lengths and compare the discrepancy with a threshold.
+val(M, dx12Cm, Z) :- measurement(M), val(M, p1xCm, X), val(M, p2xCm, Y), sub(X, Y, Z).
+val(M, dx51Cm, Z) :- measurement(M), val(M, p5xCm, X), val(M, p1xCm, Y), sub(X, Y, Z).
+val(M, dx53Cm, Z) :- measurement(M), val(M, p5xCm, X), val(M, p3xCm, Y), sub(X, Y, Z).
+val(M, dx62Cm, Z) :- measurement(M), val(M, p6xCm, X), val(M, p2xCm, Y), sub(X, Y, Z).
+val(M, dx64Cm, Z) :- measurement(M), val(M, p6xCm, X), val(M, p4xCm, Y), sub(X, Y, Z).
+val(M, dy12Cm, Z) :- measurement(M), val(M, p1yCm, X), val(M, p2yCm, Y), sub(X, Y, Z).
+val(M, dy13Cm, Z) :- measurement(M), val(M, p1yCm, X), val(M, p3yCm, Y), sub(X, Y, Z).
+val(M, dy24Cm, Z) :- measurement(M), val(M, p2yCm, X), val(M, p4yCm, Y), sub(X, Y, Z).
+val(M, dy53Cm, Z) :- measurement(M), val(M, p5yCm, X), val(M, p3yCm, Y), sub(X, Y, Z).
+val(M, dy64Cm, Z) :- measurement(M), val(M, p6yCm, X), val(M, p4yCm, Y), sub(X, Y, Z).
+val(M, cL1, Z) :- measurement(M), val(M, dy12Cm, Y), val(M, dx12Cm, X), div(Y, X, Z).
+val(M, dL3m, Z) :- measurement(M), val(M, cL1, X), div(1, X, Z).
+val(M, cL3, Z) :- measurement(M), val(M, dL3m, X), sub(0, X, Z).
+val(M, pL1x1Cm, Z) :- measurement(M), val(M, cL1, X), val(M, p1xCm, Y), mul(X, Y, Z).
+val(M, pL1x2Cm, Z) :- measurement(M), val(M, cL1, X), val(M, p2xCm, Y), mul(X, Y, Z).
+val(M, pL3x3Cm, Z) :- measurement(M), val(M, cL3, X), val(M, p3xCm, Y), mul(X, Y, Z).
+val(M, pL3x4Cm, Z) :- measurement(M), val(M, cL3, X), val(M, p4xCm, Y), mul(X, Y, Z).
+val(M, dd13Cm, Z) :- measurement(M), val(M, pL1x1Cm, X), val(M, pL3x3Cm, Y), sub(X, Y, Z).
+val(M, ddy13Cm, Z) :- measurement(M), val(M, dd13Cm, X), val(M, dy13Cm, Y), sub(X, Y, Z).
+val(M, dd24Cm, Z) :- measurement(M), val(M, pL1x2Cm, X), val(M, pL3x4Cm, Y), sub(X, Y, Z).
+val(M, ddy24Cm, Z) :- measurement(M), val(M, dd24Cm, X), val(M, dy24Cm, Y), sub(X, Y, Z).
+val(M, ddL13, Z) :- measurement(M), val(M, cL1, X), val(M, cL3, Y), sub(X, Y, Z).
+val(M, pL1dx51Cm, Z) :- measurement(M), val(M, cL1, X), val(M, dx51Cm, Y), mul(X, Y, Z).
+val(M, pL1dx62Cm, Z) :- measurement(M), val(M, cL1, X), val(M, dx62Cm, Y), mul(X, Y, Z).
+val(M, p5xCm, Z) :- measurement(M), val(M, ddy13Cm, X), val(M, ddL13, Y), div(X, Y, Z).
+val(M, p5yCm, Z) :- measurement(M), val(M, pL1dx51Cm, X), val(M, p1yCm, Y), add(X, Y, Z).
+val(M, p6xCm, Z) :- measurement(M), val(M, ddy24Cm, X), val(M, ddL13, Y), div(X, Y, Z).
+val(M, p6yCm, Z) :- measurement(M), val(M, pL1dx62Cm, X), val(M, p2yCm, Y), add(X, Y, Z).
+val(M, sdx53Cm2, Z) :- measurement(M), val(M, dx53Cm, X), pow(X, 2, Z).
+val(M, sdx64Cm2, Z) :- measurement(M), val(M, dx64Cm, X), pow(X, 2, Z).
+val(M, sdy53Cm2, Z) :- measurement(M), val(M, dy53Cm, X), pow(X, 2, Z).
+val(M, sdy64Cm2, Z) :- measurement(M), val(M, dy64Cm, X), pow(X, 2, Z).
+val(M, ssd53Cm2, Z) :- measurement(M), val(M, sdx53Cm2, X), val(M, sdy53Cm2, Y), add(X, Y, Z).
+val(M, ssd64Cm2, Z) :- measurement(M), val(M, sdx64Cm2, X), val(M, sdy64Cm2, Y), add(X, Y, Z).
+val(M, d53Cm, Z) :- measurement(M), val(M, ssd53Cm2, X), pow(X, 0.5, Z).
+val(M, d64Cm, Z) :- measurement(M), val(M, ssd64Cm2, X), pow(X, 0.5, Z).
+val(M, dCm, Z) :- measurement(M), val(M, d53Cm, X), val(M, d64Cm, Y), sub(X, Y, Z).
+
+% concise output layer
+type(M, lld_alarm) :- measurement(M), val(M, dCm, D), threshold(M, lld_alarm_threshold_cm, T), sub(0, T, Negt), lt(D, Negt).
+type(M, lld_alarm) :- measurement(M), val(M, dCm, D), threshold(M, lld_alarm_threshold_cm, T), gt(D, T).
+lld_left_length_cm(M, L) :- type(M, lld_alarm), val(M, d53Cm, L).
+lld_right_length_cm(M, R) :- type(M, lld_alarm), val(M, d64Cm, R).
+lld_discrepancy_cm(M, D) :- type(M, lld_alarm), val(M, dCm, D).
+lld_threshold_cm(M, T) :- type(M, lld_alarm), threshold(M, lld_alarm_threshold_cm, T).
+lld_reason(M, "discrepancy below negative threshold") :- type(M, lld_alarm).

package/examples/manufacturing-quality-control.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/map-four-color-search.pl

@@ -0,0 +1,65 @@
+% Four-colour search for the European Union neighbour graph.
+%
+% This is a finite executable version of the source map-colouring example.  The
+% neighbour facts are the EU country graph from the original input, represented
+% with lowercase atom names.  `once/1` asks for one valid colouring rather than
+% enumerating all possible four-colour assignments.
+
+materialize(four_color_answer, 2).
+
+color(red).
+color(green).
+color(blue).
+color(yellow).
+
+place_order([belgium, netherlands, luxemburg, france, germany, italy, denmark, ireland, greece, spain, portugal, austria, sweden, finland, cyprus, malta, poland, hungary, czech_republic, slovakia, slovenia, estonia, latvia, lithuania, bulgaria, romania, croatia]).
+
+neighbours(belgium, [france, netherlands, luxemburg, germany]).
+neighbours(netherlands, [belgium, germany]).
+neighbours(luxemburg, [belgium, france, germany]).
+neighbours(france, [spain, belgium, luxemburg, germany, italy]).
+neighbours(germany, [netherlands, belgium, luxemburg, denmark, france, austria, poland, czech_republic]).
+neighbours(italy, [france, austria, slovenia]).
+neighbours(denmark, [germany]).
+neighbours(ireland, []).
+neighbours(greece, [bulgaria]).
+neighbours(spain, [france, portugal]).
+neighbours(portugal, [spain]).
+neighbours(austria, [czech_republic, germany, hungary, italy, slovenia, slovakia]).
+neighbours(sweden, [finland]).
+neighbours(finland, [sweden]).
+neighbours(cyprus, []).
+neighbours(malta, []).
+neighbours(poland, [germany, czech_republic, slovakia, lithuania]).
+neighbours(hungary, [austria, slovakia, romania, croatia, slovenia]).
+neighbours(czech_republic, [germany, poland, slovakia, austria]).
+neighbours(slovakia, [czech_republic, poland, hungary, austria]).
+neighbours(slovenia, [austria, italy, hungary, croatia]).
+neighbours(estonia, [latvia]).
+neighbours(latvia, [estonia, lithuania]).
+neighbours(lithuania, [latvia, poland]).
+neighbours(bulgaria, [romania, greece]).
+neighbours(romania, [hungary, bulgaria]).
+neighbours(croatia, [slovenia, hungary]).
+
+% Colour the tail first, like the source Prolog program.  That gives each
+% colour choice the already-coloured suffix to check against and avoids
+% generating many doomed prefixes.
+valid_color(Place, Color, Assigned) :-
+  neighbours(Place, Neighbors),
+  not((member([Neighbor, Color], Assigned), member(Neighbor, Neighbors))).
+
+place_pairs([], []).
+place_pairs([Place|Rest], [[Place, _]|Pairs]) :-
+  place_pairs(Rest, Pairs).
+
+color_places([]).
+color_places([[Place, Color]|Tail]) :-
+  color_places(Tail),
+  color(Color),
+  valid_color(Place, Color, Tail).
+
+four_color_answer(european_union, Coloring) :-
+  place_order(Places),
+  place_pairs(Places, Coloring),
+  once(color_places(Coloring)).

package/examples/markov-logic-network.pl

@@ -0,0 +1,87 @@
+% Markov Logic Network style scoring over a tiny finite domain.
+%
+% Seam is deterministic, so this is not a probabilistic MLN engine.  The
+% example encodes the usual MLN MAP idea explicitly: enumerate possible worlds,
+% mark which weighted soft formulas each world satisfies, sum the weights, and
+% choose the highest-scoring world.  Weights are stored as integer tenths of a
+% log weight so the example stays reproducible without floating-point noise.
+
+materialize(mlnWeight, 2).
+materialize(mlnWorld, 2).
+materialize(mlnSatisfied, 2).
+materialize(mlnViolated, 2).
+materialize(mlnContribution, 3).
+materialize(mlnWorldScore, 2).
+materialize(mlnMapWorld, 2).
+materialize(mlnConclusion, 2).
+
+% Evidence and candidate hidden assignments.
+person(alice).
+person(bob).
+friend(alice, bob).
+observed_smokes(alice).
+
+candidate_world(w_bob_not_smokes_not_cancer, no, no).
+candidate_world(w_bob_not_smokes_cancer, no, yes).
+candidate_world(w_bob_smokes_not_cancer, yes, no).
+candidate_world(w_bob_smokes_cancer, yes, yes).
+
+% Soft formulas are weighted log features.
+formula_weight_tenths(friend_smoking, 20).
+formula_weight_tenths(smoking_causes_cancer, 13).
+formula_weight_tenths(cancer_is_rare, 6).
+
+% World interpretation for Bob.  Alice's smoking status is observed evidence.
+smokes_in_world(World, alice) :-
+  candidate_world(World, _, _),
+  observed_smokes(alice).
+smokes_in_world(World, bob) :- candidate_world(World, yes, _).
+cancer_in_world(World, bob) :- candidate_world(World, _, yes).
+
+% Grounded soft formulas for this tiny domain:
+%   friend_smoking:        friend(alice,bob) and smokes(alice) => smokes(bob)
+%   smoking_causes_cancer: smokes(bob) => cancer(bob)
+%   cancer_is_rare:        not cancer(bob)
+formula_satisfied(World, friend_smoking) :-
+  friend(alice, bob),
+  smokes_in_world(World, alice),
+  smokes_in_world(World, bob).
+
+formula_satisfied(World, smoking_causes_cancer) :-
+  candidate_world(World, no, _).
+formula_satisfied(World, smoking_causes_cancer) :-
+  smokes_in_world(World, bob),
+  cancer_in_world(World, bob).
+
+formula_satisfied(World, cancer_is_rare) :-
+  candidate_world(World, _, no).
+
+formula_violated(World, Formula) :-
+  candidate_world(World, _, _),
+  formula_weight_tenths(Formula, _),
+  not(formula_satisfied(World, Formula)).
+
+contribution_tenths(World, Formula, Weight) :-
+  formula_satisfied(World, Formula),
+  formula_weight_tenths(Formula, Weight).
+
+world_score_tenths(World, Score) :-
+  candidate_world(World, _, _),
+  sumall(Weight, contribution_tenths(World, Formula, Weight), Score).
+
+map_world(World, Score) :-
+  aggregate_max(Candidate_score, Candidate_world,
+    world_score_tenths(Candidate_world, Candidate_score),
+    Score, World).
+
+mlnWeight(Formula, log_weight_tenths(Weight)) :- formula_weight_tenths(Formula, Weight).
+mlnWorld(World, world(smokes(bob, Smokes), cancer(bob, Cancer))) :-
+  candidate_world(World, Smokes, Cancer).
+mlnSatisfied(World, Formula) :- formula_satisfied(World, Formula).
+mlnViolated(World, Formula) :- formula_violated(World, Formula).
+mlnContribution(World, Formula, log_weight_tenths(Weight)) :-
+  contribution_tenths(World, Formula, Weight).
+mlnWorldScore(World, log_weight_tenths(Score)) :- world_score_tenths(World, Score).
+mlnMapWorld(World, log_weight_tenths(Score)) :- map_world(World, Score).
+mlnConclusion(case, "MAP world predicts that Bob smokes and has cancer") :-
+  map_world(w_bob_smokes_cancer, _).

package/examples/matrix-chain-order.pl

@@ -0,0 +1,79 @@
+% Matrix-chain multiplication order by tabled interval dynamic programming.
+%
+% cost(I, J, Cost) is the minimum scalar multiplication cost for matrices I..J.
+% best_split/3 records which split obtains that cost, and parenthesization/3
+% reconstructs one optimal multiplication tree.
+materialize(matrix_chain_answer, 2).
+
+table(cost, 3).
+
+% Matrix dimensions are stored as adjacent p-values: matrix I has dimensions P_{I-1} x P_I.
+
+% Dimensions for the CLRS-style chain: A1 is 30x35, A2 is 35x15, and so on.
+% The dim/2 facts store boundary dimensions, so multiplying Ai..Ak by A(k+1)..Aj
+% costs dim(I-1) * dim(K) * dim(J).
+dim(0, 30).
+dim(1, 35).
+dim(2, 15).
+dim(3, 5).
+dim(4, 10).
+dim(5, 20).
+dim(6, 25).
+
+matrix_count(6).
+
+cost(I, I, 0) :- matrix_count(N), between(1, N, I).
+cost(I, J, Cost) :-
+  lt(I, J),
+  aggregate_min(Splitcost, K,
+    (between(I, J, K),
+     lt(K, J),
+     cost(I, K, Left),
+     add(K, 1, K1),
+     cost(K1, J, Right),
+     sub(I, 1, I0),
+     dim(I0, Rows),
+     dim(K, Shared),
+     dim(J, Cols),
+     mul(Rows, Shared, First),
+     mul(First, Cols, Multcost),
+     add(Left, Right, Partial),
+     add(Partial, Multcost, Splitcost)),
+    Cost, _bestk).
+
+best_split(I, J, K) :-
+  lt(I, J),
+  aggregate_min(Splitcost, K,
+    (between(I, J, K),
+     lt(K, J),
+     cost(I, K, Left),
+     add(K, 1, K1),
+     cost(K1, J, Right),
+     sub(I, 1, I0),
+     dim(I0, Rows),
+     dim(K, Shared),
+     dim(J, Cols),
+     mul(Rows, Shared, First),
+     mul(First, Cols, Multcost),
+     add(Left, Right, Partial),
+     add(Partial, Multcost, Splitcost)),
+    _cost, K).
+
+parenthesization(I, I, matrix(I)).
+parenthesization(I, J, product(Lefttree, Righttree)) :-
+  lt(I, J),
+  best_split(I, J, K),
+  add(K, 1, K1),
+  parenthesization(I, K, Lefttree),
+  parenthesization(K1, J, Righttree).
+
+matrix_chain_answer(min_cost, Cost) :- cost(1, 6, Cost).
+matrix_chain_answer(best_split_1_6, K) :- best_split(1, 6, K).
+matrix_chain_answer(best_order, Tree) :- parenthesization(1, 6, Tree).
+subproblem(I, J, Cost) :-
+  matrix_count(N),
+  between(1, N, I),
+  between(I, N, J),
+  cost(I, J, Cost).
+
+matrix_chain_answer(subproblem_count, Count) :- countall(subproblem(_i, _j, _cost), Count).