eyelang 1.7.16 → 2.0.0

package/examples/knuth-bendix-completion.eye

@@ -1,55 +0,0 @@
-% 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.eye

@@ -1,25 +0,0 @@
-% Eyelang language-identity example.
-%
-% This file intentionally uses the modern Eyelang surface syntax:
-%   - `.eye` source files instead of Prolog `.pl` files
-%   - `?` variables instead of Prolog-style uppercase variables
-%   - `table/2` for tabled recursive predicates
-%   - advisory `mode/3` and `semidet/2` declarations
-%   - angle-bracket IRI 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.eye

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

package/examples/least-squares-regression.eye

@@ -1,85 +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.
-%
-% 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.eye

@@ -1,51 +0,0 @@
-% Linear logic emulation with explicit consumable resources.
-%
-% Eyelang 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.eye

@@ -1,35 +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).
-
-% 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.eye

@@ -1,80 +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).
-
-% 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.eye

@@ -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/map-four-color-search.eye

@@ -1,65 +0,0 @@
-% 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.eye

@@ -1,87 +0,0 @@
-% Markov Logic Network style scoring over a tiny finite domain.
-%
-% Eyelang 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.eye

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