eyelang 1.2.2 → 1.3.1

package/examples/complex.pl

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

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

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

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

@@ -1,36 +0,0 @@
-% Convergents of sqrt(2) by memoized 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).
-
-memoize(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.pl

@@ -1,76 +0,0 @@
-% Control Systems example, adapted from Eyelet's input/control-system.pl.
-%
-% 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.pl

@@ -1,82 +0,0 @@
-% 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).
-
-memoize(earliest_start, 2).
-memoize(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.pl

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

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

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