eyelang 1.2.2 → 1.3.1

package/examples/exoplanet-validation-worlds.pl

@@ -1,94 +0,0 @@
-% 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.pl

@@ -1,45 +0,0 @@
-% 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.pl

@@ -1,67 +0,0 @@
-% 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.
-memoize(family_statement, 3).
-memoize(generation, 2).
-memoize(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.pl

@@ -1,61 +0,0 @@
-% 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.pl

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

@@ -1,60 +0,0 @@
-% 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.
-memoize(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.pl

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