eyeling 1.32.0 → 1.33.0

package/examples/eyelang/eyeling-family-cousins-extended.n3

@@ -0,0 +1,12 @@
+# Adapted from eyeling/examples/family-cousins.n3.
+@prefix log: <http://www.w3.org/2000/10/swap/log#>.
+@prefix : <https://eyereasoner.github.io/ns#>.
+
+:alice :parentOf :bob, :carol.
+:bob :parentOf :dave.
+:carol :parentOf :erin.
+:erin :parentOf :fay.
+
+{ ?p :parentOf ?x. ?p :parentOf ?y. ?x log:notEqualTo ?y. } => { ?x :siblingOf ?y. }.
+{ ?a :parentOf ?x. ?b :parentOf ?y. ?a :siblingOf ?b. ?x log:notEqualTo ?y. } => { ?x :cousinOf ?y. }.
+{ ?x :cousinOf ?y. } => { ?x :relatedTo ?y. }.

package/examples/eyelang/eyeling-fastpow.n3

@@ -0,0 +1,10 @@
+# Adapted from eyeling/examples/fastpow.n3.
+# Computes powers with math:exponentiation and derives named results.
+@prefix math: <http://www.w3.org/2000/10/swap/math#>.
+@prefix : <https://eyereasoner.github.io/eyeling/examples/fastpow#>.
+
+:case1 :base 2; :exponent 10.
+:case2 :base 3; :exponent 7.
+
+{ ?C :base ?B; :exponent ?E. (?B ?E) math:exponentiation ?V. } => { ?C :power ?V. }.
+{ ?C :power ?V. ?V math:greaterThan 1000. } => { ?C :largePower true. }.

package/examples/eyelang/eyeling-fibonacci.n3

@@ -0,0 +1,44 @@
+# Adapted from eyeling/examples/fibonacci.n3.
+# Uses the same :fibonacci relation, but with a fast-doubling helper so the
+# example remains practical under eyelang's RDF/N3 compatibility materializer.
+@prefix math: <http://www.w3.org/2000/10/swap/math#>.
+@prefix : <https://eyereasoner.github.io/eyeling/examples/fibonacci#>.
+
+{ ?N :fibonacci ?F } <= { (?N ?F ?Next) :fibPair true }.
+
+{ (0 0 1) :fibPair true } <= true.
+
+# even N: F(2k)=F(k)*(2*F(k+1)-F(k)), F(2k+1)=F(k)^2+F(k+1)^2
+{ (?N ?C ?D) :fibPair true } <= {
+  ?N math:greaterThan 0.
+  (?N 2) math:integerQuotient ?K.
+  (?K ?A ?B) :fibPair true.
+  (?B 2) math:product ?TwoB.
+  (?TwoB ?A) math:difference ?TwoBMinusA.
+  (?A ?TwoBMinusA) math:product ?C.
+  (?A ?A) math:product ?AA.
+  (?B ?B) math:product ?BB.
+  (?AA ?BB) math:sum ?D.
+  (?N 2) math:remainder 0.
+}.
+
+# odd N: F(2k+1)=D, F(2k+2)=C+D
+{ (?N ?D ?Next) :fibPair true } <= {
+  ?N math:greaterThan 0.
+  (?N 2) math:integerQuotient ?K.
+  (?K ?A ?B) :fibPair true.
+  (?B 2) math:product ?TwoB.
+  (?TwoB ?A) math:difference ?TwoBMinusA.
+  (?A ?TwoBMinusA) math:product ?C.
+  (?A ?A) math:product ?AA.
+  (?B ?B) math:product ?BB.
+  (?AA ?BB) math:sum ?D.
+  (?C ?D) math:sum ?Next.
+  (?N 2) math:remainder 1.
+}.
+
+{ 0 :fibonacci ?F0. } => { :fibonacci_0 :value ?F0. }.
+{ 1 :fibonacci ?F1. } => { :fibonacci_1 :value ?F1. }.
+{ 10 :fibonacci ?F10. } => { :fibonacci_10 :value ?F10. }.
+{ 100 :fibonacci ?F100. } => { :fibonacci_100 :value ?F100. }.
+{ 1000 :fibonacci ?F1000. } => { :fibonacci_1000 :value ?F1000. }.

package/examples/eyelang/eyeling-french-cities-reachability.n3

@@ -0,0 +1,22 @@
+# Adapted from eyeling/examples/french-cities.n3.
+# One-way routes are paths; paths compose transitively.
+@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>.
+@prefix owl: <http://www.w3.org/2002/07/owl#>.
+@prefix : <https://eyereasoner.github.io/eyeling/examples/french-cities#>.
+
+:paris :oneway :orleans, :chartres, :amiens.
+:orleans :oneway :blois, :bourges.
+:blois :oneway :tours.
+:chartres :oneway :lemans.
+:lemans :oneway :angers, :tours.
+:angers :oneway :nantes.
+:oneway rdfs:subPropertyOf :path.
+:path a owl:TransitiveProperty.
+
+{ ?P rdfs:subPropertyOf ?Q. ?S ?P ?O. } => { ?S ?Q ?O. }.
+{ ?P a owl:TransitiveProperty. ?S ?P ?X. ?X ?P ?O. } => { ?S ?P ?O. }.
+{ ?C :path :nantes. } => { ?C :canReach :nantes. }.
+{ :paris :canReach :nantes. } => { :report :reachableCity :paris. }.
+{ :chartres :canReach :nantes. } => { :report :reachableCity :chartres. }.
+{ :lemans :canReach :nantes. } => { :report :reachableCity :lemans. }.
+{ :angers :canReach :nantes. } => { :report :reachableCity :angers. }.

package/examples/eyelang/eyeling-goldbach-small.n3

@@ -0,0 +1,22 @@
+# Adapted from eyeling/examples/goldbach-1000.n3.
+# A tiny Goldbach witness check.
+@prefix math: <http://www.w3.org/2000/10/swap/math#>.
+@prefix : <https://eyereasoner.github.io/eyeling/examples/goldbach#>.
+
+:two a :Prime.
+:three a :Prime.
+:five a :Prime.
+:seven a :Prime.
+:eleven a :Prime.
+:twelve :even true.
+:eighteen :even true.
+
+:twelve :candidate (:five :seven).
+:eighteen :candidate (:seven :eleven).
+:five :value 5.
+:seven :value 7.
+:eleven :value 11.
+:twelve :value 12.
+:eighteen :value 18.
+
+{ ?N :candidate (?A ?B). ?A a :Prime; :value ?AV. ?B a :Prime; :value ?BV. (?AV ?BV) math:sum ?NV. ?N :value ?NV. } => { ?N :goldbachWitness (?A ?B). }.

package/examples/eyelang/eyeling-good-cobbler.n3

@@ -0,0 +1,9 @@
+# Adapted from eyeling/examples/good-cobbler.n3.
+# Term-logic style statement represented with an RDF collection.
+@prefix : <https://eyereasoner.github.io/eyeling/examples/good-cobbler#>.
+
+:joe :is (:good :Cobbler).
+:ann :is (:careful :Tailor).
+
+{ ?X :is (:good ?Y). } => { ?X :goodAt ?Y. }.
+{ ?X :goodAt ?Y. } => { :test :hasGoodWorker ?X. }.

package/examples/eyelang/eyeling-list-builtins.n3

@@ -0,0 +1,10 @@
+# Inspired by eyeling list/collection examples and the SWAP list builtin family.
+@prefix list: <http://www.w3.org/2000/10/swap/list#>.
+@prefix : <https://eyereasoner.github.io/ns#>.
+
+{ (3 1 2) list:first ?First. } => { :demo :firstNumber ?First. }.
+{ (3 1 2) list:rest ?Rest. } => { :demo :restNumbers ?Rest. }.
+{ (3 1 2) list:reverse ?Reverse. } => { :demo :reverseNumbers ?Reverse. }.
+{ ("beta" "alpha" "gamma") list:sort ?Sorted. } => { :demo :sortedWords ?Sorted. }.
+{ 2 list:in (3 1 2). } => { :demo :containsTwo true. }.
+{ ((1 2) (3 4)) list:append ?Flat. } => { :demo :flatNumbers ?Flat. }.

package/examples/eyelang/eyeling-list-collection-extra.n3

@@ -0,0 +1,9 @@
+# Adapted from eyeling/examples/collection.n3.
+# More list operations over N3 collections.
+@prefix list: <http://www.w3.org/2000/10/swap/list#>.
+@prefix : <https://eyereasoner.github.io/eyeling/examples/list-extra#>.
+
+:shopping :items (:tea :milk :bread).
+
+{ :shopping :items ?L. ?L list:first ?First. ?L list:rest ?Rest. ?L list:reverse ?Rev. ?L list:length ?Len. } => { :shopping :first ?First; :rest ?Rest; :reverse ?Rev; :length ?Len. }.
+{ :shopping :items ?L. ?L list:member :milk. } => { :shopping :containsMilk true. }.

package/examples/eyelang/eyeling-math-builtins.n3

@@ -0,0 +1,9 @@
+# Inspired by eyeling builtin examples for the SWAP math namespace.
+@prefix math: <http://www.w3.org/2000/10/swap/math#>.
+@prefix : <https://eyereasoner.github.io/ns#>.
+
+{ (2 3 5) math:sum ?Total. } => { :calc :sum ?Total. }.
+{ (21 4) math:integerQuotient ?Q. } => { :calc :integerQuotient ?Q. }.
+{ (21 4) math:remainder ?R. } => { :calc :remainder ?R. }.
+{ (2 8) math:exponentiation ?Pow. } => { :calc :power ?Pow. }.
+{ -3 math:absoluteValue ?Abs. } => { :calc :absolute ?Abs. }.

package/examples/eyelang/eyeling-string-builtins-extra.n3

@@ -0,0 +1,9 @@
+# Adapted from eyeling string builtin examples.
+# Exercises scrape, replace, and formatting-style concatenation.
+@prefix string: <http://www.w3.org/2000/10/swap/string#>.
+@prefix : <https://eyereasoner.github.io/eyeling/examples/string-extra#>.
+
+:msg :text "sensor:A17 status:OK".
+
+{ :msg :text ?T. (?T "sensor:([A-Z0-9]+)") string:scrape ?Sensor. (?T "status:OK" "status:GREEN") string:replace ?Green. } => { :msg :sensor ?Sensor; :greenText ?Green. }.
+{ :msg :sensor ?S. ("device-" ?S) string:concatenation ?Id. } => { :msg :deviceId ?Id. }.

package/examples/eyelang/eyeling-string-builtins.n3

@@ -0,0 +1,10 @@
+# Inspired by eyeling builtin examples for the SWAP string namespace.
+@prefix string: <http://www.w3.org/2000/10/swap/string#>.
+@prefix : <https://eyereasoner.github.io/ns#>.
+
+:msg :text "Hello Eyelang".
+
+{ :msg :text ?Text. ?Text string:contains "Eye". } => { :msg :mentionsEye true. }.
+{ :msg :text ?Text. ?Text string:length ?Len. } => { :msg :length ?Len. }.
+{ ("N3" " + " "RDF 1.2") string:concatenation ?Label. } => { :msg :label ?Label. }.
+{ ("Hello Eyelang" "Eye(.*)") string:scrape ?Tail. } => { :msg :scrapedTail ?Tail. }.

package/examples/eyelang/eyeling-time-builtins.n3

@@ -0,0 +1,11 @@
+# Inspired by eyeling examples that use time/date builtins.
+@prefix time: <http://www.w3.org/2000/10/swap/time#>.
+@prefix xsd: <http://www.w3.org/2001/XMLSchema#>.
+@prefix : <https://eyereasoner.github.io/ns#>.
+
+:event :at "2026-06-15T10:20:30Z"^^xsd:dateTime.
+
+{ :event :at ?T. ?T time:year ?Y. } => { :event :year ?Y. }.
+{ :event :at ?T. ?T time:month ?M. } => { :event :month ?M. }.
+{ :event :at ?T. ?T time:day ?D. } => { :event :day ?D. }.
+{ :event :at ?T. ?T time:hour ?H. } => { :event :hour ?H. }.

package/examples/eyelang/eyeling-time-components-extra.n3

@@ -0,0 +1,10 @@
+# Adapted from eyeling builtin/time examples.
+# Extracts date-time components.
+@prefix time: <http://www.w3.org/2000/10/swap/time#>.
+@prefix xsd: <http://www.w3.org/2001/XMLSchema#>.
+@prefix : <https://eyereasoner.github.io/eyeling/examples/time-extra#>.
+
+:event :at "2026-06-15T10:30:45Z"^^xsd:dateTime.
+
+{ :event :at ?T. ?T time:year ?Y. ?T time:month ?M. ?T time:day ?D. ?T time:hour ?H. } => { :event :year ?Y; :month ?M; :day ?D; :hour ?H. }.
+{ :event :year 2026; :month 6; :day 15. } => { :event :dateCheck true. }.

package/examples/eyelang/eyeling-witch.n3

@@ -0,0 +1,10 @@
+# Adapted from eyeling/examples/witch.n3.
+# Monty Python-style rule chain.
+@prefix : <https://eyereasoner.github.io/eye/reasoning/witch#>.
+
+:elsie a :WOMAN, :BURNS.
+:robin a :MAN, :BURNS.
+:agnes a :WOMAN.
+
+{ ?x a :BURNS. ?x a :WOMAN. } => { ?x a :WITCH. }.
+{ ?x a :WITCH. } => { ?x a :WEIGHS_THE_SAME_AS_A_DUCK. }.

package/examples/eyelang/family-cousins.n3

@@ -0,0 +1,17 @@
+# Adapted from eyereasoner/eyeling examples/family-cousins.n3.
+# This version avoids eyeling math built-ins and keeps to RDF/N3 Horn rules.
+PREFIX : <http://example.org/family#>
+
+:Adam :parentOf :Bob, :Carol .
+:Bob :parentOf :Dave, :Eve .
+:Carol :parentOf :Frank, :Grace .
+:Bob :differentFrom :Carol .
+:Carol :differentFrom :Bob .
+
+{ ?Grandparent :parentOf ?Parent1 .
+  ?Grandparent :parentOf ?Parent2 .
+  ?Parent1 :parentOf ?Child1 .
+  ?Parent2 :parentOf ?Child2 .
+  ?Parent1 :differentFrom ?Parent2 . }
+=>
+{ ?Child1 :cousin ?Child2 . } .

package/examples/eyelang/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, Formula), formula_binary(Formula, S, P, 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/eyelang/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/eyelang/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/eyelang/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/eyelang/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").