eyelang 0.1.0

package/examples/exoplanet-validation-worlds.pl

@@ -0,0 +1,88 @@
+% 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.
+materialize(ppvPlanetGivenDetection, 2).
+materialize(confirmsInWorld, 2).
+materialize(rejectsInWorld, 2).
+materialize(status, 2).
+materialize(reason, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+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).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+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).
+
+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

@@ -0,0 +1,43 @@
+% Tiny expression evaluator adapted from Eyeling's expression-eval.n3 example.
+% Data: (2 * 3) + (10 - 4) = 12.
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(result, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+% Leaves are number/2 facts; internal nodes name an operator and two children.
+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).
+
+% Evaluation is recursive over the expression tree.
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+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

@@ -0,0 +1,65 @@
+% 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).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+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)
+)).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+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

@@ -0,0 +1,53 @@
+% Fast exponentiation examples adapted from Eyeling fastpow.n3.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(pow, 2).
+materialize(powSlow, 2).
+materialize(powMod1e6, 2).
+materialize(tower, 2).
+materialize(towerMod1e6, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+% pow/3 uses exponentiation by squaring.
+pow(_Base, 0, 1).
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+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 values from the Eyeling output set.
+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

@@ -0,0 +1,83 @@
+% Adapted from Eyeling's fft8-numeric.n3.
+% A radix-2 FFT over explicit complex pairs c(Re, Im).
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(fft, 2).
+materialize(dcComponent, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+% Twiddle factors are encoded as complex pairs c(Real, Imag).
+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.
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+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([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

@@ -0,0 +1,53 @@
+% Memoize the fast-doubling helper: several requested Fibonacci numbers reuse
+% the same half-size subproblems.
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(fibonacci, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+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).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+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

@@ -0,0 +1,70 @@
+% EYE-inspired field nitrogen balance case study.
+% Fields are classified from soil N, fertilizer N, losses, and crop demand.
+
+% field(Field, SoilN, FertilizerN, LossFraction, CropDemandN).
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+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).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+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).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+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(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").