eyelang 1.2.2 → 1.3.0

package/examples/existential-rule.eye

@@ -0,0 +1,21 @@
+% Existential introduction with explicit witnesses.
+% Eyeling's original N3 rule creates existential blank nodes; in Eyelang the
+% same idea is represented by deterministic Skolem-style witness terms so the
+% generated individual is visible in ordinary output.
+%
+% The materialized is/2 facts show the person-to-witness relation.
+materialize(is, 2).
+
+% Source data says which people are humans and which witness term belongs to
+% each human.  The single rule below is the existential-style introduction step.
+
+type(socrates, human).
+type(plato, human).
+
+witness(socrates, sk_0).
+witness(plato, sk_1).
+
+% In proof output this rule is the step that explains why each witness exists.
+is(?person, ?witness) :-
+  type(?person, human),
+  witness(?person, ?witness).

package/examples/exoplanet-validation-worlds.eye

@@ -0,0 +1,94 @@
+% EYE reasoning-inspired example: exoplanet candidate validation worlds.
+%
+% Four simplified worlds classify candidate transit signals using either Bayes,
+% sensitivity-only reasoning, a heuristic threshold, or a stricter Bayesian rule.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+%
+% The example is intentionally qualitative: several independent signals must
+% align before a candidate is promoted from plausible to confirmed in a world.
+materialize(ppvPlanetGivenDetection, 2).
+materialize(confirmsInWorld, 2).
+materialize(rejectsInWorld, 2).
+materialize(status, 2).
+materialize(reason, 2).
+
+% candidate/4 stores occurrence rate, sensitivity, and specificity.  world/2
+% names the alternative validation policies applied to the same signals.
+candidate(rare_wide_orbit, 0.001, 0.99, 0.99).
+candidate(mstar_short_period, 0.20, 0.99, 0.99).
+candidate(common_hot_neptune_good, 0.25, 0.95, 0.97).
+candidate(common_hot_neptune_low_spec, 0.25, 0.95, 0.90).
+
+world(w0, full_bayes_reference).
+world(w1, sensitivity_only_naive).
+world(w2, occurrence_sensitivity_specificity_heuristic).
+world(w3, cautious_bayes_threshold).
+
+% The Bayes world computes positive predictive value, while the other worlds
+% intentionally use simpler or stricter thresholds for contrast.
+ppv_planet(?candidate, ?ppv) :-
+  candidate(?candidate, ?occurrence, ?sensitivity, ?specificity),
+  mul(?sensitivity, ?occurrence, ?numerator),
+  sub(1.0, ?occurrence, ?noplanetprior),
+  sub(1.0, ?specificity, ?falsepositiverate),
+  mul(?falsepositiverate, ?noplanetprior, ?falsepositivemass),
+  add(?numerator, ?falsepositivemass, ?denominator),
+  div(?numerator, ?denominator, ?ppv).
+
+% The world predicates encode different modelling assumptions for the same candidate.
+confirms_in_world(?candidate, w0) :-
+  ppv_planet(?candidate, ?ppv),
+  ge(?ppv, 0.90).
+
+rejects_in_world(?candidate, w0) :-
+  ppv_planet(?candidate, ?ppv),
+  lt(?ppv, 0.90).
+
+confirms_in_world(?candidate, w1) :-
+  candidate(?candidate, ?occurrence, ?sensitivity, ?specificity),
+  ge(?sensitivity, 0.95).
+
+rejects_in_world(?candidate, w1) :-
+  candidate(?candidate, ?occurrence, ?sensitivity, ?specificity),
+  lt(?sensitivity, 0.95).
+
+confirms_in_world(?candidate, w2) :-
+  candidate(?candidate, ?occurrence, ?sensitivity, ?specificity),
+  ge(?occurrence, 0.05),
+  ge(?sensitivity, 0.90),
+  ge(?specificity, 0.97).
+
+rejects_in_world(?candidate, w2) :-
+  candidate(?candidate, ?occurrence, ?sensitivity, ?specificity),
+  lt(?occurrence, 0.05).
+
+rejects_in_world(?candidate, w2) :-
+  candidate(?candidate, ?occurrence, ?sensitivity, ?specificity),
+  lt(?sensitivity, 0.90).
+
+rejects_in_world(?candidate, w2) :-
+  candidate(?candidate, ?occurrence, ?sensitivity, ?specificity),
+  lt(?specificity, 0.97).
+
+confirms_in_world(?candidate, w3) :-
+  ppv_planet(?candidate, ?ppv),
+  ge(?ppv, 0.93).
+
+rejects_in_world(?candidate, w3) :-
+  ppv_planet(?candidate, ?ppv),
+  lt(?ppv, 0.93).
+
+pattern_matches(report) :-
+  confirms_in_world(rare_wide_orbit, w1),
+  rejects_in_world(rare_wide_orbit, w0), rejects_in_world(rare_wide_orbit, w2), rejects_in_world(rare_wide_orbit, w3),
+  confirms_in_world(mstar_short_period, w0), confirms_in_world(mstar_short_period, w1), confirms_in_world(mstar_short_period, w2), confirms_in_world(mstar_short_period, w3),
+  confirms_in_world(common_hot_neptune_good, w0), confirms_in_world(common_hot_neptune_good, w1), confirms_in_world(common_hot_neptune_good, w2), rejects_in_world(common_hot_neptune_good, w3),
+  confirms_in_world(common_hot_neptune_low_spec, w1),
+  rejects_in_world(common_hot_neptune_low_spec, w0), rejects_in_world(common_hot_neptune_low_spec, w2), rejects_in_world(common_hot_neptune_low_spec, w3).
+
+ppvPlanetGivenDetection(?candidate, ?ppv) :- ppv_planet(?candidate, ?ppv).
+confirmsInWorld(?candidate, ?world) :- confirms_in_world(?candidate, ?world).
+rejectsInWorld(?candidate, ?world) :- rejects_in_world(?candidate, ?world).
+status(exoplanet_validation_worlds, expected_world_pattern) :- pattern_matches(report).
+reason(exoplanet_validation_worlds, "Bayesian worlds account for occurrence and false positives while the naive world trusts sensitivity alone") :- pattern_matches(report).

package/examples/expression-eval.eye

@@ -0,0 +1,45 @@
+% Tiny expression evaluator adapted from Eyeling's expression-eval.n3 example.
+%
+% The expression tree represents (2 * 3) + (10 - 4).  value/2 recursively folds
+% the tree, so proof output shows how the final result 12 is assembled from
+% smaller arithmetic subexpressions.
+materialize(result, 2).
+
+% The expression tree is data: number/2 labels leaves, expr/4 labels internal
+% operator nodes, and root/1 chooses the term to evaluate.
+number(n2, 2).
+number(n3, 3).
+number(n10, 10).
+number(n4, 4).
+
+expr(eMul, mul, n2, n3).
+expr(eSub, sub, n10, n4).
+expr(eAdd, add, eMul, eSub).
+root(eAdd).
+
+% Each arithmetic operator has its own rule, which makes the proof tree mirror
+% the shape of the expression tree.
+value(?node, ?value) :-
+  number(?node, ?value).
+
+value(?node, ?value) :-
+  expr(?node, add, ?left, ?right),
+  value(?left, ?leftvalue),
+  value(?right, ?rightvalue),
+  add(?leftvalue, ?rightvalue, ?value).
+
+value(?node, ?value) :-
+  expr(?node, sub, ?left, ?right),
+  value(?left, ?leftvalue),
+  value(?right, ?rightvalue),
+  sub(?leftvalue, ?rightvalue, ?value).
+
+value(?node, ?value) :-
+  expr(?node, mul, ?left, ?right),
+  value(?left, ?leftvalue),
+  value(?right, ?rightvalue),
+  mul(?leftvalue, ?rightvalue, ?value).
+
+result(root, ?value) :-
+  root(?node),
+  value(?node, ?value).

package/examples/family-cousins.eye

@@ -0,0 +1,67 @@
+% Memoize scoped family projection and recursive labels; cousin derivation asks
+% for the same generation and branch facts many times.
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(generation, 2).
+materialize(branch, 2).
+materialize(cousin, 2).
+
+% The family tree is scoped inside family_graph/2.  family_statement/3 projects
+% only the parent and seedBranch facts that the cousin rules need.
+table(family_statement, 3).
+table(generation, 2).
+table(branch, 2).
+
+% Family-cousins derivation adapted from Eyeling family-cousins.n3.
+% Generation numbers are derived from parent links; branch labels distinguish
+% descendants of Bob from descendants of Carol.
+% The family tree and seed branch labels are quoted as a small formula term, so
+% the rules derive from scoped family data rather than global relationship facts.
+
+family_graph(familyGraph, (
+  parent(adam, bob),
+  parent(adam, carol),
+  parent(bob, dave),
+  parent(bob, eve),
+  parent(carol, frank),
+  parent(carol, grace),
+  parent(dave, heidi),
+  parent(eve, ivan),
+  parent(frank, judy),
+  seedBranch(dave, b),
+  seedBranch(eve, b),
+  seedBranch(frank, c),
+  seedBranch(grace, c)
+)).
+
+% generation/2 walks parent links from Adam, branch/2 propagates seed labels,
+% and cousin/2 combines equal generation with different branches.
+family_statement(?s, ?p, ?o) :- family_graph(familyGraph, ?context), holds(?context, ?p, [?s, ?o]).
+
+parent(?parent, ?child) :- family_statement(?parent, parent, ?child).
+branch(?person, ?branch) :- family_statement(?person, seedBranch, ?branch).
+
+different(b, c).
+different(c, b).
+
+generation(adam, 0).
+generation(?child, ?next) :-
+  parent(?parent, ?child),
+  generation(?parent, ?gen),
+  add(?gen, 1, ?next).
+
+branch(?child, ?branch) :-
+  parent(?parent, ?child),
+  branch(?parent, ?branch).
+
+derived_branch(?child, ?branch) :-
+  parent(?parent, ?child),
+  branch(?parent, ?branch).
+
+cousin(?x, ?y) :-
+  generation(?x, ?gen),
+  generation(?y, ?gen),
+  branch(?x, ?bx),
+  branch(?y, ?by),
+  different(?bx, ?by).
+
+branch(?person, ?branch) :- derived_branch(?person, ?branch).

package/examples/fastpow.eye

@@ -0,0 +1,61 @@
+% Fast exponentiation examples adapted from Eyeling fastpow.n3.
+%
+% pow/3 demonstrates exponentiation by squaring, while pow_mod/4 performs the
+% same recursion under a modulus so huge powers remain small enough for ordinary
+% output and proof display.
+%
+% The file also includes deliberately slower and tower-style reports, making it a
+% small arithmetic benchmark for recursive definitions, modular arithmetic, and
+% bounded output selection.
+materialize(pow, 2).
+materialize(powSlow, 2).
+materialize(powMod1e6, 2).
+materialize(tower, 2).
+materialize(towerMod1e6, 2).
+
+% Base case and parity split for exponentiation by squaring.  Even exponents
+% square the half-power; odd exponents peel off one base factor.
+pow(?_base, 0, 1).
+% Recursive even/odd clauses reduce the exponent quickly rather than counting
+% down one multiplication at a time.
+pow(?base, ?exp, ?value) :-
+  gt(?exp, 0),
+  mod(?exp, 2, 0),
+  div(?exp, 2, ?half),
+  pow(?base, ?half, ?halfvalue),
+  mul(?halfvalue, ?halfvalue, ?value).
+pow(?base, ?exp, ?value) :-
+  gt(?exp, 0),
+  mod(?exp, 2, 1),
+  sub(?exp, 1, ?evenexp),
+  pow(?base, ?evenexp, ?evenvalue),
+  mul(?base, ?evenvalue, ?value).
+
+% pow_mod/4 applies the modulus at each multiplication to keep values small.
+pow_mod(?_base, 0, ?_mod, 1).
+pow_mod(?base, ?exp, ?mod, ?value) :-
+  gt(?exp, 0),
+  mod(?exp, 2, 0),
+  div(?exp, 2, ?half),
+  pow_mod(?base, ?half, ?mod, ?halfvalue),
+  mul(?halfvalue, ?halfvalue, ?square),
+  mod(?square, ?mod, ?value).
+pow_mod(?base, ?exp, ?mod, ?value) :-
+  gt(?exp, 0),
+  mod(?exp, 2, 1),
+  sub(?exp, 1, ?evenexp),
+  pow_mod(?base, ?evenexp, ?mod, ?evenvalue),
+  mul(?base, ?evenvalue, ?product),
+  mod(?product, ?mod, ?value).
+
+% Tetration examples are kept as facts here so this file focuses on fast power
+% and modular power rather than an additional tower evaluator.
+tower(2, 4, 65536).
+tower_mod(2, 5, 1000000, 156736).
+
+pow([2, 10], ?value) :- pow(2, 10, ?value).
+powSlow([2, 10], ?value) :- pow(2, 10, ?value).
+powMod1e6([2, 10000], ?value) :- pow_mod(2, 10000, 1000000, ?value).
+powMod1e6([3, 10000], ?value) :- pow_mod(3, 10000, 1000000, ?value).
+tower([2, 4], ?value) :- tower(2, 4, ?value).
+towerMod1e6([2, 5], ?value) :- tower_mod(2, 5, 1000000, ?value).

package/examples/fft8-numeric.eye

@@ -0,0 +1,85 @@
+% Adapted from Eyeling's fft8-numeric.n3.
+%
+% This is an 8-point radix-2 FFT over explicit complex pairs c(Real, Imag).
+% The rules are deliberately unrolled enough to keep proofs readable while still
+% showing butterfly composition, twiddle factors, and selected output bins.
+materialize(fft, 2).
+materialize(dcComponent, 2).
+
+% Twiddle factors are encoded as complex pairs.  Keeping them as facts makes the
+% numerical transform deterministic and keeps every multiplication visible.
+w8(0, c(1.0, 0.0)).
+w8(1, c(0.7071067811865476, -0.7071067811865476)).
+w8(2, c(0.0, -1.0)).
+w8(3, c(-0.7071067811865476, -0.7071067811865476)).
+w8(4, c(-1.0, 0.0)).
+w8(5, c(-0.7071067811865476, 0.7071067811865476)).
+w8(6, c(0.0, 1.0)).
+w8(7, c(0.7071067811865476, 0.7071067811865476)).
+
+% Complex arithmetic is expressed through ordinary numeric built-ins.  These
+% helpers are then composed into two-point, four-point, and eight-point FFTs.
+c_add(c(?ar, ?ai), c(?br, ?bi), c(?cr, ?ci)) :-
+  add(?ar, ?br, ?cr),
+  add(?ai, ?bi, ?ci).
+
+c_sub(c(?ar, ?ai), c(?br, ?bi), c(?cr, ?ci)) :-
+  sub(?ar, ?br, ?cr),
+  sub(?ai, ?bi, ?ci).
+
+c_mul(c(?ar, ?ai), c(?br, ?bi), c(?cr, ?ci)) :-
+  mul(?ar, ?br, ?ac),
+  mul(?ai, ?bi, ?bd),
+  sub(?ac, ?bd, ?cr),
+  mul(?ar, ?bi, ?ad),
+  mul(?ai, ?br, ?bc),
+  add(?ad, ?bc, ?ci).
+
+fft1([?x], [c(?x, 0.0)]).
+
+fft2([?x0, ?x1], [?y0, ?y1]) :-
+  fft1([?x0], [?e0]),
+  fft1([?x1], [?o0]),
+  c_add(?e0, ?o0, ?y0),
+  c_sub(?e0, ?o0, ?y1).
+
+fft4([?x0, ?x1, ?x2, ?x3], [?y0, ?y1, ?y2, ?y3]) :-
+  fft2([?x0, ?x2], [?e0, ?e1]),
+  fft2([?x1, ?x3], [?o0, ?o1]),
+  w8(2, ?w1),
+  c_mul(?w1, ?o1, ?t1),
+  c_add(?e0, ?o0, ?y0),
+  c_add(?e1, ?t1, ?y1),
+  c_sub(?e0, ?o0, ?y2),
+  c_sub(?e1, ?t1, ?y3).
+
+% Split even/odd samples, transform halves, then combine with W8 factors.
+% fft8/2 composes two four-point FFTs with the four required twiddle factors.
+fft8([?x0, ?x1, ?x2, ?x3, ?x4, ?x5, ?x6, ?x7], [?y0, ?y1, ?y2, ?y3, ?y4, ?y5, ?y6, ?y7]) :-
+  fft4([?x0, ?x2, ?x4, ?x6], [?e0, ?e1, ?e2, ?e3]),
+  fft4([?x1, ?x3, ?x5, ?x7], [?o0, ?o1, ?o2, ?o3]),
+  w8(1, ?w1),
+  w8(2, ?w2),
+  w8(3, ?w3),
+  c_mul(?w1, ?o1, ?t1),
+  c_mul(?w2, ?o2, ?t2),
+  c_mul(?w3, ?o3, ?t3),
+  c_add(?e0, ?o0, ?y0),
+  c_add(?e1, ?t1, ?y1),
+  c_add(?e2, ?t2, ?y2),
+  c_add(?e3, ?t3, ?y3),
+  c_sub(?e0, ?o0, ?y4),
+  c_sub(?e1, ?t1, ?y5),
+  c_sub(?e2, ?t2, ?y6),
+  c_sub(?e3, ?t3, ?y7).
+
+wave(ramp8, [0, 1, 2, 3, 4, 5, 6, 7]).
+wave(alternating8, [1, -1, 1, -1, 1, -1, 1, -1]).
+
+fft(?wave, ?spectrum) :-
+  wave(?wave, ?samples),
+  fft8(?samples, ?spectrum).
+
+dcComponent(?wave, ?dc) :-
+  wave(?wave, ?samples),
+  fft8(?samples, [?dc|?_]).

package/examples/fibonacci.eye

@@ -0,0 +1,60 @@
+% Fibonacci numbers by fast doubling.
+%
+% The public fibonacci/2 relation is bounded by fib_case/1 facts, while fib_pair/3
+% computes F(N) and F(N+1) together.  This exposes a logarithmic recursive
+% algorithm in a small relational program instead of enumerating all predecessors.
+%
+% Memoization is important for the large cases: several requested Fibonacci
+% numbers reuse the same half-size fib_pair/3 subproblems.
+materialize(fibonacci, 2).
+
+% fib_case/1 bounds the public queries, while fib_pair/3 implements the
+% fast-doubling recurrence F(2n), F(2n+1) over arbitrary-size integers.
+table(fib_pair, 3).
+
+% BigInt Fibonacci via fast doubling, implemented in Prolog using generic
+% decimal add/sub/mul built-ins.  The result predicate follows Eyeling's
+% fibonacci.n3 output shape: N fibonacci Value.
+fib_case(0).
+fib_case(1).
+fib_case(10).
+fib_case(100).
+fib_case(1000).
+fib_case(10000).
+
+% The even and odd fib_pair/3 clauses share the same half-size recursive call;
+% memoization makes repeated large cases reuse those subproblems.
+fib(?n, ?value) :- fib_pair(?n, ?value, ?_next).
+
+fib_pair(0, 0, 1).
+fib_pair(?n, ?f, ?g) :-
+  gt(?n, 0),
+  div(?n, 2, ?half),
+  fib_pair(?half, ?a, ?b),
+  mul(?b, 2, ?twob),
+  sub(?twob, ?a, ?twobminusa),
+  mul(?a, ?twobminusa, ?c),
+  mul(?a, ?a, ?aa),
+  mul(?b, ?b, ?bb),
+  add(?aa, ?bb, ?d),
+  mod(?n, 2, 0),
+  eq(?f, ?c),
+  eq(?g, ?d).
+fib_pair(?n, ?f, ?g) :-
+  gt(?n, 0),
+  div(?n, 2, ?half),
+  fib_pair(?half, ?a, ?b),
+  mul(?b, 2, ?twob),
+  sub(?twob, ?a, ?twobminusa),
+  mul(?a, ?twobminusa, ?c),
+  mul(?a, ?a, ?aa),
+  mul(?b, ?b, ?bb),
+  add(?aa, ?bb, ?d),
+  mod(?n, 2, 1),
+  add(?c, ?d, ?next),
+  eq(?f, ?d),
+  eq(?g, ?next).
+
+fibonacci(?n, ?value) :-
+  fib_case(?n),
+  fib(?n, ?value).

package/examples/field-nitrogen-balance.eye

@@ -0,0 +1,73 @@
+% EYE-inspired field nitrogen balance case study.
+%
+% field(Field, SoilN, FertilizerN, LossFraction, CropDemandN) stores a compact
+% nutrient budget.  Rules derive retained nitrogen, deficit, surplus, and a
+% leaching-risk index before assigning each field a status.
+materialize(availableN_kg_ha, 2).
+materialize(deficitN_kg_ha, 2).
+materialize(surplusN_kg_ha, 2).
+materialize(leachingIndex, 2).
+materialize(status, 2).
+materialize(highestLeachingRisk, 2).
+materialize(reason, 2).
+
+% The four fields cover under-supplied, balanced, and over-supplied scenarios
+% with different loss fractions so leaching risk is not just total surplus.
+field(low_input, 25, 40, 0.10, 110).
+field(balanced_loam, 45, 80, 0.12, 110).
+field(sandy_high, 30, 150, 0.35, 105).
+field(clay_surplus, 70, 90, 0.08, 120).
+
+% total_n/2 and available_n/2 build the nutrient budget; surplus/deficit and
+% leaching rules then explain the resulting field status.
+total_n(?f, ?total) :-
+  field(?f, ?soil, ?fert, ?_, ?_),
+  add(?soil, ?fert, ?total).
+
+available_n(?f, ?avail) :-
+  total_n(?f, ?total),
+  field(?f, ?_, ?_, ?loss, ?_),
+  sub(1.0, ?loss, ?retained),
+  mul(?total, ?retained, ?avail).
+
+% surplus_n/2 and deficit_n/2 split the signed balance into reportable quantities.
+surplus_n(?f, ?surplus) :-
+  available_n(?f, ?avail),
+  field(?f, ?_, ?_, ?_, ?demand),
+  gt(?avail, ?demand),
+  sub(?avail, ?demand, ?surplus).
+
+surplus_n(?f, 0.0) :-
+  available_n(?f, ?avail),
+  field(?f, ?_, ?_, ?_, ?demand),
+  le(?avail, ?demand).
+
+deficit_n(?f, ?deficit) :-
+  available_n(?f, ?avail),
+  field(?f, ?_, ?_, ?_, ?demand),
+  lt(?avail, ?demand),
+  sub(?demand, ?avail, ?deficit).
+
+deficit_n(?f, 0.0) :-
+  available_n(?f, ?avail),
+  field(?f, ?_, ?_, ?_, ?demand),
+  ge(?avail, ?demand).
+
+leaching_index(?f, ?index) :-
+  surplus_n(?f, ?surplus),
+  field(?f, ?_, ?_, ?loss, ?_),
+  mul(?surplus, ?loss, ?index).
+
+status(?f, under_supplied) :- deficit_n(?f, ?d), gt(?d, 10.0).
+status(?f, balanced) :- deficit_n(?f, ?d), surplus_n(?f, ?s), le(?d, 10.0), le(?s, 10.0).
+status(?f, over_supplied) :- surplus_n(?f, ?s), gt(?s, 10.0).
+
+availableN_kg_ha(?f, ?a) :- available_n(?f, ?a).
+deficitN_kg_ha(?f, ?d) :- deficit_n(?f, ?d).
+surplusN_kg_ha(?f, ?s) :- surplus_n(?f, ?s).
+leachingIndex(?f, ?i) :- leaching_index(?f, ?i).
+highestLeachingRisk(field_nitrogen_balance, sandy_high) :-
+  leaching_index(sandy_high, ?sandy),
+  leaching_index(clay_surplus, ?clay),
+  gt(?sandy, ?clay).
+reason(field_nitrogen_balance, "available nitrogen is total input retained after losses compared with crop demand").