eyelang 1.2.2 → 1.3.0

package/examples/complex.eye

@@ -0,0 +1,133 @@
+% Complex numbers, adapted from Eyeling complex.n3.
+%
+% Complex values are represented as two-item lists [Real, Imaginary], matching
+% the pair-shaped pair lists used by the Eyeling source.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+%
+% The example derives arithmetic identities, polar conversions, powers, roots,
+% exponential/trigonometric functions, and distance/normalization results from
+% a small complex-number toolkit.
+materialize(complex_power, 4).
+materialize(complex_function, 4).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+pi(3.141592653589793).
+e(2.718281828459045).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+% z^w is evaluated through polar/log form, exposing useful intermediate proof steps.
+complex_exponentiation([?a, ?b], [?c, ?d], [?e, ?f]) :-
+  complex_polar([?a, ?b], [?r, ?t]),
+  pow(?r, ?c, ?z1),
+  neg(?d, ?z2),
+  mul(?z2, ?t, ?z3),
+  e(?euler),
+  pow(?euler, ?z3, ?z4),
+  log(?r, ?z5),
+  mul(?d, ?z5, ?z6),
+  mul(?c, ?t, ?z7),
+  add(?z6, ?z7, ?z8),
+  cos(?z8, ?z9),
+  mul(?z1, ?z4, ?z1z4),
+  mul(?z1z4, ?z9, ?e),
+  sin(?z8, ?z10),
+  mul(?z1z4, ?z10, ?f).
+
+complex_asin([?a, ?b], [?c, ?d]) :-
+  add(1, ?a, ?z1),
+  pow(?z1, 2, ?z2),
+  pow(?b, 2, ?z3),
+  add(?z2, ?z3, ?z4),
+  pow(?z4, 0.5, ?z5),
+  sub(1, ?a, ?z6),
+  pow(?z6, 2, ?z7),
+  add(?z7, ?z3, ?z8),
+  pow(?z8, 0.5, ?z9),
+  sub(?z5, ?z9, ?z10),
+  div(?z10, 2, ?e),
+  add(?z5, ?z9, ?z11),
+  div(?z11, 2, ?f),
+  asin(?e, ?c),
+  pow(?f, 2, ?z12),
+  sub(?z12, 1, ?z13),
+  pow(?z13, 0.5, ?z14),
+  add(?f, ?z14, ?z15),
+  log(?z15, ?d).
+
+complex_acos([?a, ?b], [?c, ?d]) :-
+  add(1, ?a, ?z1),
+  pow(?z1, 2, ?z2),
+  pow(?b, 2, ?z3),
+  add(?z2, ?z3, ?z4),
+  pow(?z4, 0.5, ?z5),
+  sub(1, ?a, ?z6),
+  pow(?z6, 2, ?z7),
+  add(?z7, ?z3, ?z8),
+  pow(?z8, 0.5, ?z9),
+  sub(?z5, ?z9, ?z10),
+  div(?z10, 2, ?e),
+  add(?z5, ?z9, ?z11),
+  div(?z11, 2, ?f),
+  acos(?e, ?c),
+  pow(?f, 2, ?z12),
+  sub(?z12, 1, ?z13),
+  pow(?z13, 0.5, ?z14),
+  add(?f, ?z14, ?z15),
+  log(?z15, ?u),
+  neg(?u, ?d).
+
+complex_polar([?x, ?y], [?r, ?tp]) :-
+  pow(?x, 2, ?z1),
+  pow(?y, 2, ?z2),
+  add(?z1, ?z2, ?z3),
+  pow(?z3, 0.5, ?r),
+  abs(?x, ?z4),
+  div(?z4, ?r, ?z5),
+  acos(?z5, ?t),
+  complex_dial(?x, ?y, ?t, ?tp).
+
+complex_dial(?x, ?y, ?t, ?tp) :-
+  ge(?x, 0),
+  ge(?y, 0),
+  add(0, ?t, ?tp).
+
+complex_dial(?x, ?y, ?t, ?tp) :-
+  lt(?x, 0),
+  ge(?y, 0),
+  pi(?pi),
+  sub(?pi, ?t, ?tp).
+
+complex_dial(?x, ?y, ?t, ?tp) :-
+  lt(?x, 0),
+  lt(?y, 0),
+  pi(?pi),
+  add(?pi, ?t, ?tp).
+
+complex_dial(?x, ?y, ?t, ?tp) :-
+  ge(?x, 0),
+  lt(?y, 0),
+  pi(?pi),
+  mul(?pi, 2, ?z1),
+  sub(?z1, ?t, ?tp).
+
+% Named result rows keep the example output readable.  Each row records the
+% operation name, the input value(s), and the computed complex result rather
+% than packing all assertions into one large nested term.
+complex_power(sqrt_minus_one, [-1, 0], [0.5, 0], ?result) :-
+  complex_exponentiation([-1, 0], [0.5, 0], ?result).
+
+complex_power(e_to_i_pi, [2.718281828459045, 0], [0, 3.141592653589793], ?result) :-
+  complex_exponentiation([2.718281828459045, 0], [0, 3.141592653589793], ?result).
+
+complex_power(i_to_i, [0, 1], [0, 1], ?result) :-
+  complex_exponentiation([0, 1], [0, 1], ?result).
+
+complex_power(e_to_minus_pi_over_two, [2.718281828459045, 0], [-1.57079632679, 0], ?result) :-
+  complex_exponentiation([2.718281828459045, 0], [-1.57079632679, 0], ?result).
+
+complex_function(asin, two, [2, 0], ?result) :-
+  complex_asin([2, 0], ?result).
+
+complex_function(acos, two, [2, 0], ?result) :-
+  complex_acos([2, 0], ?result).

package/examples/composition-of-injective-functions-is-injective.eye

@@ -0,0 +1,50 @@
+% Composition of injective functions is injective, adapted from Eyeling's
+% examples/composition-of-injective-functions-is-injective.n3.
+%
+% The output mirrors the Eyeling golden result shape:
+% sameInputByCompositeInjectivity(h, a, b) and the symmetric counterpart.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(sameInputByCompositeInjectivity, 3).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+inX(a).
+inX(b).
+inY(c).
+inY(d).
+inZ(e).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+sameTerm(?x, ?x) :- inX(?x).
+sameTerm(?x, ?x) :- inY(?x).
+sameTerm(?x, ?x) :- inZ(?x).
+sameTerm(?y, ?x) :- sameTerm(?x, ?y).
+
+app(f, a, c).
+app(f, b, d).
+app(g, c, e).
+app(g, d, e).
+
+injective(f).
+injective(g).
+compositeOf(h, g, f).
+
+app(?h, ?x, ?z) :-
+  compositeOf(?h, ?g, ?f),
+  app(?f, ?x, ?y),
+  app(?g, ?y, ?z).
+
+sameTerm(?x, ?y) :-
+  injective(?f),
+  app(?f, ?x, ?u),
+  app(?f, ?y, ?v),
+  sameTerm(?u, ?v).
+
+sameInputByCompositeInjectivity(?h, ?x, ?y) :-
+  compositeOf(?h, ?g, ?f),
+  injective(?g),
+  injective(?f),
+  app(?h, ?x, ?z),
+  app(?h, ?y, ?z),
+  sameTerm(?x, ?y),
+  neq(?x, ?y).

package/examples/context-association.eye

@@ -0,0 +1,53 @@
+% Context association adapted from Eyeling context-association.n3.
+%
+% This version keeps the original shape: each context is named with log_nameOf
+% and its contents remain quoted formula data.  Nothing inside the three formulae
+% is asserted globally unless a rule explicitly projects it.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(log_nameOf, 2).
+materialize(dataGraph, 2).
+materialize(signatureGraph, 2).
+materialize(metadataGraph, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+log_nameOf(skolem_g0, foaf_name(bob, "Bob")).
+
+log_nameOf(skolem_g1, (
+  sec_proof(skolem_g0, dataSignature),
+  type(signature1, sec_DataIntegrityProof),
+  sec_cryptosuite(signature1, "ecdsa-proof-2019"),
+  sec_created(signature1, "2021-11-13T18:19:39Z"),
+  sec_verificationMethod(signature1, "https://university.example/issuers/14#key-1"),
+  sec_proofPurpose(signature1, "assertionMethod"),
+  sec_proofValue(signature1, "z58DAdFfa9SkqZMVPxAQp...jQCrfFPP2oumHKtz"),
+  sec_issuer(signature1, university),
+  sec_validFrom(signature1, "2024-04-03T00:00:00.000Z"),
+  sec_validUntil(signature1, "2025-04-03T00:00:00.000Z")
+)).
+
+log_nameOf(g3, (
+  sec_proof(skolem_g1, signature2),
+  type(signature2, sec_DataIntegrityProof),
+  sec_cryptosuite(signature2, "ecdsa-proof-2019"),
+  sec_created(signature2, "2021-11-13T18:19:39Z"),
+  sec_verificationMethod(signature2, "https://university.example/issuers/14#key-1"),
+  sec_proofPurpose(signature2, "assertionMethod"),
+  sec_proofValue(signature2, "adad123efv434r5200...dqed2t44v43das")
+)).
+
+% A tiny projection shows how a program can inspect a quoted context without
+% making the entire context globally true.
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+context_statement(?contextname, ?subject, ?predicate, ?object) :-
+  log_nameOf(?contextname, ?context),
+  holds(?context, ?predicate, [?subject, ?object]).
+
+dataGraph(association, skolem_g0) :-
+  context_statement(skolem_g0, bob, foaf_name, "Bob").
+
+signatureGraph(association, skolem_g1) :-
+  context_statement(skolem_g1, skolem_g0, sec_proof, dataSignature).
+
+metadataGraph(association, g3) :-
+  context_statement(g3, skolem_g1, sec_proof, signature2).

package/examples/context-schema-audit.eye

@@ -0,0 +1,46 @@
+% Context schema audit.
+%
+% This example needs holds/3 rather than holds/2 because the audit rule does
+% not know the predicate names or arities in advance.  It inspects a whole
+% context as data, extracts each member as Name + Args, computes the arity, and
+% checks that shape against an allowed schema.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(context_shape, 3).
+materialize(schema_violation, 3).
+
+% Program structure: each message carries heterogeneous context data.  The
+% members deliberately use different arities: heartbeat/0, source/1,
+% temperature/2, gps/3, and signature/4.
+message_context(msg_ok, (
+  heartbeat,
+  source(sensor17),
+  temperature(sensor17, 38),
+  gps(sensor17, 51, 4),
+  signature(sensor17, sha256, "9f86d081", "2026-06-18T09:30:00Z")
+)).
+
+message_context(msg_bad, (
+  heartbeat,
+  source(sensor18),
+  temperature(sensor18, 99),
+  gps(sensor18, 51),
+  tampered(sensor18)
+)).
+
+allowed_shape(heartbeat, 0).
+allowed_shape(source, 1).
+allowed_shape(temperature, 2).
+allowed_shape(gps, 3).
+allowed_shape(signature, 4).
+
+% Derivation rules: holds/3 exposes arbitrary context members as predicate name
+% plus argument list, so one generic rule can audit mixed-arity data.
+context_shape(?message, ?name, ?arity) :-
+  message_context(?message, ?context),
+  holds(?context, ?name, ?args),
+  length(?args, ?arity).
+
+schema_violation(?message, ?name, ?arity) :-
+  context_shape(?message, ?name, ?arity),
+  not(allowed_shape(?name, ?arity)).

package/examples/continued-fraction-sqrt2.eye

@@ -0,0 +1,36 @@
+% Convergents of sqrt(2) by tabled recurrence.
+%
+% conv(N, P, Q) gives the Nth numerator/denominator pair for [1; 2, 2, ...].
+% Because each convergent depends on the previous two, memoization avoids the
+% exponential recomputation that the direct Horn-clause recurrence would have.
+% pell_error/2 connects the approximation sequence with P^2 - 2Q^2 = +/-1.
+materialize(convergent_answer, 2).
+
+table(conv, 3).
+
+% Base convergents are 1/1 and 3/2.
+conv(0, 1, 1).
+conv(1, 3, 2).
+conv(?n, ?p, ?q) :-
+  gt(?n, 1),
+  sub(?n, 1, ?n1),
+  sub(?n, 2, ?n2),
+  conv(?n1, ?p1, ?q1),
+  conv(?n2, ?p2, ?q2),
+  mul(2, ?p1, ?twicep1),
+  add(?twicep1, ?p2, ?p),
+  mul(2, ?q1, ?twiceq1),
+  add(?twiceq1, ?q2, ?q).
+
+% The signed error alternates between +1 and -1 for these convergents.
+pell_error(?n, ?error) :-
+  conv(?n, ?p, ?q),
+  mul(?p, ?p, ?p2),
+  mul(?q, ?q, ?q2),
+  mul(2, ?q2, ?twiceq2),
+  sub(?p2, ?twiceq2, ?error).
+
+convergent_answer(convergent_10, fraction(?p, ?q)) :- conv(10, ?p, ?q).
+convergent_answer(convergent_15, fraction(?p, ?q)) :- conv(15, ?p, ?q).
+convergent_answer(pell_error_15, ?error) :- pell_error(15, ?error).
+convergent_answer(numerator_sum_0_to_10, ?sum) :- sumall(?p, (between(0, 10, ?n), conv(?n, ?p, ?_q)), ?sum).

package/examples/control-system.eye

@@ -0,0 +1,76 @@
+% Control Systems example, adapted from Eyelet's input/control-system.eye.
+%
+% The example combines measurements, observations, targets, logarithmic
+% feedforward compensation, square-root normalization, and nonlinear feedback.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+%
+% Each derived quantity is represented as its own predicate rather than a single
+% formula blob, making the proof trace useful for debugging a failed actuator
+% normalization or control-signal calculation.
+materialize(controlSignal, 2).
+materialize(status, 2).
+materialize(normalizedMeasurement, 2).
+materialize(log10, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+measurement(input1, [6, 11]).
+measurement(disturbance2, [45, 39]).
+measurement(input2, true).
+measurement(input3, 56967).
+measurement(disturbance1, 35766).
+measurement(output2, 24).
+
+observation(state1, 80).
+observation(state2, false).
+observation(state3, 22).
+
+target(output2, 29).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+measurement_normalized(?i, ?m) :-
+  measurement(?i, [?m1, ?m2]),
+  lt(?m1, ?m2),
+  sub(?m2, ?m1, ?delta),
+  pow(?delta, 0.5, ?m).
+
+measurement_normalized(?i, ?m1) :-
+  measurement(?i, [?m1, ?m2]),
+  ge(?m1, ?m2).
+
+log10(?value, ?result) :-
+  log(?value, ?naturallog),
+  log(10, ?naturallog10),
+  div(?naturallog, ?naturallog10, ?result).
+
+control(actuator1, ?c) :-
+  measurement_normalized(input1, ?m1),
+  measurement(input2, true),
+  measurement(disturbance1, ?d1),
+  mul(?m1, 19.6, ?proportional),
+  log10(?d1, ?compensation),
+  sub(?proportional, ?compensation, ?c).
+
+control(actuator2, ?c) :-
+  observation(state3, ?p3),
+  measurement(output2, ?m4),
+  target(output2, ?t2),
+  sub(?t2, ?m4, ?error),
+  sub(?p3, ?m4, ?differentialerror),
+  mul(5.8, ?error, ?proportional),
+  div(7.3, ?error, ?nonlinearfactor),
+  mul(?nonlinearfactor, ?differentialerror, ?differential),
+  add(?proportional, ?differential, ?c).
+
+controlSignal(?actuator, ?c) :-
+  control(?actuator, ?c).
+
+status(?actuator, active) :-
+  control(?actuator, ?_c).
+
+normalizedMeasurement(input1, ?m) :-
+  measurement_normalized(input1, ?m).
+
+log10(disturbance1, ?c) :-
+  measurement(disturbance1, ?d),
+  log10(?d, ?c).

package/examples/critical-path-schedule.eye

@@ -0,0 +1,82 @@
+% Critical-path scheduling for a small project network.
+%
+% earliest_start/2 is the maximum finish time over all predecessors; finish_time/2
+% adds task duration.  Critical tasks are reconstructed by following predecessors
+% that attain those maxima.  Memoization lets the schedule, finish date, and path
+% queries share the same project-network subproblems.
+materialize(critical_path_answer, 2).
+
+table(earliest_start, 2).
+table(finish_time, 2).
+
+% Durations are in arbitrary project time units.
+task(requirements, 2).
+task(architecture, 3).
+task(api_design, 2).
+task(database, 4).
+task(backend, 6).
+task(frontend, 5).
+task(auth, 3).
+task(integration, 4).
+task(security_review, 3).
+task(load_test, 2).
+task(launch, 1).
+
+depends(architecture, requirements).
+depends(api_design, requirements).
+depends(database, architecture).
+depends(backend, api_design).
+depends(backend, database).
+depends(frontend, api_design).
+depends(auth, architecture).
+depends(integration, backend).
+depends(integration, frontend).
+depends(integration, auth).
+depends(security_review, integration).
+depends(load_test, integration).
+depends(launch, security_review).
+depends(launch, load_test).
+
+earliest_start(?task, 0) :-
+  task(?task, ?_duration),
+  not(depends(?task, ?_pred)).
+earliest_start(?task, ?start) :-
+  depends(?task, ?_pred),
+  aggregate_max(?finish, ?pred,
+    (depends(?task, ?pred), finish_time(?pred, ?finish)),
+    ?start, ?_criticalpred).
+
+finish_time(?task, ?finish) :-
+  task(?task, ?duration),
+  earliest_start(?task, ?start),
+  add(?start, ?duration, ?finish).
+
+% For each task, choose a predecessor that determines its earliest start.
+critical_predecessor(?task, ?pred) :-
+  depends(?task, ?_anypred),
+  aggregate_max(?finish, ?p,
+    (depends(?task, ?p), finish_time(?p, ?finish)),
+    ?_bestfinish, ?pred).
+
+project_finish(?finish) :-
+  aggregate_max(?finishtime, ?task, finish_time(?task, ?finishtime), ?finish, ?_lasttask).
+
+final_task(?task) :-
+  project_finish(?finish),
+  finish_time(?task, ?finish).
+
+critical_chain(?task, ?task).
+critical_chain(?task, ?pred) :-
+  critical_predecessor(?task, ?parent),
+  critical_chain(?parent, ?pred).
+
+critical_task(?task) :-
+  final_task(?final),
+  critical_chain(?final, ?task).
+
+critical_path_answer(project_finish, ?finish) :- project_finish(?finish).
+critical_path_answer(critical_task, ?task) :- critical_task(?task).
+critical_path_answer(schedule, task(?task, ?start, ?finish)) :-
+  task(?task, ?_duration),
+  earliest_start(?task, ?start),
+  finish_time(?task, ?finish).

package/examples/cyclic-path.eye

@@ -0,0 +1,18 @@
+% Cyclic transitive closure.
+%
+% The graph deliberately contains the directed cycle a -> b -> c -> d -> a.  The
+% recursive path/2 rule therefore has to deal with cycles while still deriving
+% the reachable pairs used by the golden output.
+%
+% This is a compact regression-style example for active-goal handling in recursive
+% graph search.
+
+materialize(path, 2).
+
+arc(a, b).
+arc(b, c).
+arc(c, d).
+arc(d, a).
+
+path(?x, ?y) :- arc(?x, ?y).
+path(?x, ?z) :- arc(?x, ?y), path(?y, ?z).

package/examples/d3-group.eye

@@ -0,0 +1,99 @@
+% Eyelet-inspired D3 group example using findall/3 and sort/2.
+% The six facts are the symmetries of an equilateral triangle, with compose/3 as
+% the Cayley table and inverse/2 as the inverse relation.  Candidate subsets are
+% generated as subsequences, then filtered for subgroup closure.
+
+materialize(subgroups, 2).
+materialize(subgroupCount, 2).
+materialize(reason, 2).
+
+% Six symmetries of an equilateral triangle: identity, rotations, reflections.
+symmetry(identity).
+symmetry(rotation_120).
+symmetry(rotation_240).
+symmetry(reflection_a).
+symmetry(reflection_b).
+symmetry(reflection_c).
+
+% Cayley table for D3 composition.
+compose(identity, identity, identity).
+compose(identity, rotation_120, rotation_120).
+compose(identity, rotation_240, rotation_240).
+compose(identity, reflection_a, reflection_a).
+compose(identity, reflection_b, reflection_b).
+compose(identity, reflection_c, reflection_c).
+compose(rotation_120, identity, rotation_120).
+compose(rotation_120, rotation_120, rotation_240).
+compose(rotation_120, rotation_240, identity).
+compose(rotation_120, reflection_a, reflection_b).
+compose(rotation_120, reflection_b, reflection_c).
+compose(rotation_120, reflection_c, reflection_a).
+compose(rotation_240, identity, rotation_240).
+compose(rotation_240, rotation_120, identity).
+compose(rotation_240, rotation_240, rotation_120).
+compose(rotation_240, reflection_a, reflection_c).
+compose(rotation_240, reflection_b, reflection_a).
+compose(rotation_240, reflection_c, reflection_b).
+compose(reflection_a, identity, reflection_a).
+compose(reflection_a, rotation_120, reflection_c).
+compose(reflection_a, rotation_240, reflection_b).
+compose(reflection_a, reflection_a, identity).
+compose(reflection_a, reflection_b, rotation_240).
+compose(reflection_a, reflection_c, rotation_120).
+compose(reflection_b, identity, reflection_b).
+compose(reflection_b, rotation_120, reflection_a).
+compose(reflection_b, rotation_240, reflection_c).
+compose(reflection_b, reflection_a, rotation_120).
+compose(reflection_b, reflection_b, identity).
+compose(reflection_b, reflection_c, rotation_240).
+compose(reflection_c, identity, reflection_c).
+compose(reflection_c, rotation_120, reflection_b).
+compose(reflection_c, rotation_240, reflection_a).
+compose(reflection_c, reflection_a, rotation_240).
+compose(reflection_c, reflection_b, rotation_120).
+compose(reflection_c, reflection_c, identity).
+% Each candidate subgroup must also contain inverses.
+inverse(identity, identity).
+inverse(rotation_120, rotation_240).
+inverse(rotation_240, rotation_120).
+inverse(reflection_a, reflection_a).
+inverse(reflection_b, reflection_b).
+inverse(reflection_c, reflection_c).
+
+% Candidate subsets are generated as subsequences of the sorted symmetry list.
+subsequence([], []).
+subsequence([?head | ?tail], [?head | ?rest]) :-
+  subsequence(?tail, ?rest).
+subsequence([?_head | ?tail], ?rest) :-
+  subsequence(?tail, ?rest).
+
+all_symmetries(?symmetries) :-
+  findall(?x, symmetry(?x), ?raw),
+  sort(?raw, ?symmetries).
+
+% A valid subgroup is closed under both composition and inverse.
+closed_under_composition(?group) :-
+  not((member(?x, ?group), member(?y, ?group), compose(?x, ?y, ?z), not(member(?z, ?group)))).
+
+closed_under_inverse(?group) :-
+  not((member(?x, ?group), inverse(?x, ?y), not(member(?y, ?group)))).
+
+valid_group(?group) :-
+  all_symmetries(?all),
+  subsequence(?all, ?group),
+  member(identity, ?group),
+  closed_under_composition(?group),
+  closed_under_inverse(?group).
+
+all_subgroups(?groups) :-
+  findall(?g, valid_group(?g), ?raw),
+  sort(?raw, ?groups).
+
+subgroups(d3_group, ?groups) :-
+  all_subgroups(?groups).
+
+subgroupCount(d3_group, ?count) :-
+  all_subgroups(?groups),
+  length(?groups, ?count).
+
+reason(d3_group, "findall enumerates candidate subgroups and sort gives canonical subgroup order").

package/examples/dairy-energy-balance.eye

@@ -0,0 +1,66 @@
+% EYE-inspired dairy energy balance case study.
+%
+% cow(Cow, BodyWeightKg, MilkKgPerDay, RationEnergyMcalPerKgDM, IntakeKgDM)
+% records a small herd.  Rules estimate maintenance demand, milk-production
+% demand, ration supply, and the resulting energy-balance class.
+materialize(energyBalance_Mcal, 2).
+materialize(rationSupportedMilk_kg, 2).
+materialize(status, 2).
+materialize(reason, 2).
+materialize(strongestDeficit, 2).
+
+% Four cows cover negative, near-neutral, and positive balance cases.
+cow(early_lactation, 650, 38, 6.4, 22).
+cow(mid_lactation, 610, 24, 6.5, 26).
+cow(late_lactation, 580, 16, 6.7, 25).
+cow(grazing, 540, 18, 5.8, 21).
+
+% Maintenance scales with body weight; milk requirement scales with daily milk.
+maintenance(?c, ?m) :-
+  cow(?c, ?weight, ?_, ?_, ?_),
+  mul(?weight, 0.08, ?m).
+
+milk_requirement(?c, ?r) :-
+  cow(?c, ?_, ?milk, ?_, ?_),
+  mul(?milk, 5.0, ?r).
+
+ration_supply(?c, ?s) :-
+  cow(?c, ?_, ?_, ?density, ?intake),
+  mul(?density, ?intake, ?s).
+
+total_requirement(?c, ?r) :-
+  maintenance(?c, ?m),
+  milk_requirement(?c, ?milkr),
+  add(?m, ?milkr, ?r).
+
+% energy_balance/2 is intake minus maintenance and milk-production demand.
+energy_balance(?c, ?b) :-
+  ration_supply(?c, ?s),
+  total_requirement(?c, ?r),
+  sub(?s, ?r, ?b).
+
+ration_supported_milk(?c, ?milk) :-
+  ration_supply(?c, ?s),
+  maintenance(?c, ?m),
+  sub(?s, ?m, ?availableformilk),
+  div(?availableformilk, 5.0, ?milk).
+
+status(?c, negative_energy_balance) :-
+  energy_balance(?c, ?b),
+  lt(?b, -5.0).
+
+status(?c, near_neutral_energy_balance) :-
+  energy_balance(?c, ?b),
+  ge(?b, -5.0),
+  le(?b, 5.0).
+
+status(?c, positive_energy_balance) :-
+  energy_balance(?c, ?b),
+  gt(?b, 5.0).
+
+energyBalance_Mcal(?c, ?b) :- energy_balance(?c, ?b).
+rationSupportedMilk_kg(?c, ?m) :- ration_supported_milk(?c, ?m).
+reason(dairy_energy_balance, "ration supply minus maintenance and milk energy requirement determines the class").
+strongestDeficit(dairy_energy_balance, early_lactation) :-
+  status(early_lactation, negative_energy_balance),
+  status(late_lactation, positive_energy_balance).