seam-lang 2.0.0

package/examples/ev-range-worlds.pl

@@ -0,0 +1,87 @@
+% EYE-inspired electric-vehicle range worlds.
+%
+% The same trips are evaluated under four modelling worlds: base consumption,
+% speed-aware consumption, physics-aware consumption, and physics plus safety
+% reserve.  This makes the output a small possible-worlds comparison.
+materialize(safeInWorld, 2).
+materialize(riskyInWorld, 2).
+materialize(reason, 2).
+materialize(status, 2).
+
+% trip_data/7 stores distance, speed, temperature, payload, battery, and base
+% energy use.  The factors below adjust base consumption rather than duplicating
+% one rule per trip/world pair.
+trip(city_errand).
+trip(winter_highway).
+trip(heavy_delivery).
+trip(cold_commute).
+
+% trip_data(Trip, DistanceKm, SpeedKmh, TemperatureC, PayloadKg, BatteryKWh, BaseKWhPerKm).
+trip_data(city_errand, 40, 45, 20, 100, 30, 0.18).
+trip_data(winter_highway, 260, 115, -5, 400, 60, 0.20).
+trip_data(heavy_delivery, 180, 80, 15, 700, 55, 0.22).
+trip_data(cold_commute, 120, 90, -8, 100, 35, 0.19).
+
+% Each world adds a different combination of speed, temperature, payload, and
+% reserve factors before comparing required energy with usable battery.
+speed_factor(T, 1.20) :- trip_data(T, _, S, _, _, _, _), gt(S, 100).
+speed_factor(T, 1.00) :- trip_data(T, _, S, _, _, _, _), le(S, 100).
+
+temperature_factor(T, 1.15) :- trip_data(T, _, _, Temp, _, _, _), lt(Temp, 0).
+temperature_factor(T, 1.00) :- trip_data(T, _, _, Temp, _, _, _), ge(Temp, 0).
+
+payload_factor(T, 1.15) :- trip_data(T, _, _, _, P, _, _), gt(P, 500).
+payload_factor(T, 1.08) :- trip_data(T, _, _, _, P, _, _), gt(P, 250), le(P, 500).
+payload_factor(T, 1.00) :- trip_data(T, _, _, _, P, _, _), le(P, 250).
+
+base_energy(T, E) :-
+  trip_data(T, D, _, _, _, _, B),
+  mul(D, B, E).
+
+required_energy(T, w1, E) :-
+  base_energy(T, E).
+
+required_energy(T, w2, E) :-
+  base_energy(T, Base),
+  speed_factor(T, Sf),
+  mul(Base, Sf, E).
+
+required_energy(T, w0, E) :-
+  base_energy(T, Base),
+  speed_factor(T, Sf),
+  temperature_factor(T, Tf),
+  payload_factor(T, Pf),
+  mul(Base, Sf, A),
+  mul(A, Tf, B),
+  mul(B, Pf, E).
+
+required_energy(T, w3, E) :-
+  required_energy(T, w0, W0),
+  mul(W0, 1.30, E).
+
+% safe_in_world/2 compares required trip energy with usable battery capacity.
+safe_in_world(T, W) :-
+  trip_data(T, _, _, _, _, Battery, _),
+  required_energy(T, W, Required),
+  le(Required, Battery).
+
+risky_in_world(T, W) :-
+  trip_data(T, _, _, _, _, Battery, _),
+  required_energy(T, W, Required),
+  gt(Required, Battery).
+
+safeInWorld(T, W) :- safe_in_world(T, W).
+riskyInWorld(T, W) :- risky_in_world(T, W).
+reason(winter_highway, "cold fast payload trip exceeds battery in physics-aware worlds") :-
+  risky_in_world(winter_highway, w0),
+  risky_in_world(winter_highway, w2),
+  risky_in_world(winter_highway, w3),
+  safe_in_world(winter_highway, w1).
+reason(heavy_delivery, "safety buffer turns a physics-safe delivery into a cautious risk") :-
+  safe_in_world(heavy_delivery, w0),
+  risky_in_world(heavy_delivery, w3).
+status(ev_range_worlds, expected_world_pattern) :-
+  safe_in_world(city_errand, w3),
+  risky_in_world(winter_highway, w0),
+  risky_in_world(heavy_delivery, w3),
+  safe_in_world(cold_commute, w3).

package/examples/existential-rule.pl

@@ -0,0 +1,14 @@
+% Existential-style introduction with explicit Herbrand witnesses.
+%
+% Seam has no blank nodes and no existential variables in rule heads.  A
+% rule can still express the practical executable shape of an existential
+% consequence by putting a named functional term directly in the head.
+
+materialize(is, 2).
+
+type(socrates, human).
+type(plato, human).
+
+% In proof output this rule is the step that explains each visible witness.
+is(Person, human_witness(Person)) :-
+  type(Person, human).

package/examples/exoplanet-validation-worlds.pl

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

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

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

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

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

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

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