eyeprolog 0.5.3

package/examples/bayes-diagnosis.pl

@@ -0,0 +1,114 @@
+% Bayesian diagnosis adapted from Eyeling bayes-diagnosis.n3.
+% The integer-scaled rules keep the model executable in eyeprolog.  The emitted
+% relations use Eyeling's full posterior vocabulary instead of rounded basis
+% points, so this example is comparable with examples/output/bayes-diagnosis.n3
+% in the Eyeling repository.
+
+% Output declarations: host-supplied goals select the relations written to this example's golden output.
+%% goal: scores(X0, X1)
+
+%% goal: evidenceTotal(X0, X1)
+
+%% goal: result(X0, X1)
+
+%% goal: disease(X0, X1)
+
+%% goal: unnormalized(X0, X1)
+
+%% goal: posterior(X0, X1)
+
+
+% Program structure: facts set up the scenario, and rules derive the queried conclusions.
+disease(covid19).
+disease(influenza).
+disease(allergicRhinitis).
+disease(bacterialPneumonia).
+
+prior(covid19, 50).
+prior(influenza, 30).
+prior(allergicRhinitis, 100).
+prior(bacterialPneumonia, 10).
+
+p_given(covid19, fever, 700).
+p_given(covid19, dryCough, 650).
+p_given(covid19, lossOfSmell, 400).
+p_given(covid19, sneezing, 150).
+p_given(covid19, shortBreath, 200).
+
+p_given(influenza, fever, 800).
+p_given(influenza, dryCough, 500).
+p_given(influenza, lossOfSmell, 50).
+p_given(influenza, sneezing, 200).
+p_given(influenza, shortBreath, 100).
+
+p_given(allergicRhinitis, fever, 50).
+p_given(allergicRhinitis, dryCough, 150).
+p_given(allergicRhinitis, lossOfSmell, 100).
+p_given(allergicRhinitis, sneezing, 800).
+p_given(allergicRhinitis, shortBreath, 50).
+
+p_given(bacterialPneumonia, fever, 700).
+p_given(bacterialPneumonia, dryCough, 600).
+p_given(bacterialPneumonia, lossOfSmell, 20).
+p_given(bacterialPneumonia, sneezing, 50).
+p_given(bacterialPneumonia, shortBreath, 600).
+
+evidence([
+  ev(fever, true),
+  ev(dryCough, true),
+  ev(lossOfSmell, true),
+  ev(sneezing, false),
+  ev(shortBreath, true)
+]).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+factor(Disease, Symptom, true, P) :- p_given(Disease, Symptom, P).
+factor(Disease, Symptom, false, Q) :-
+  p_given(Disease, Symptom, P),
+  (Q is 1000 - P).
+
+likelihood(_disease, [], Acc, Acc).
+likelihood(Disease, [ev(Symptom, Present)|Rest], Acc, Value) :-
+  factor(Disease, Symptom, Present, Factor),
+  (Next is Acc * Factor),
+  likelihood(Disease, Rest, Next, Value).
+
+score(Disease, Score) :-
+  prior(Disease, Prior),
+  evidence(Evidence),
+  likelihood(Disease, Evidence, 1, Likelihood),
+  (Score is Prior * Likelihood).
+
+total_score(Total) :-
+  score(covid19, S1),
+  score(influenza, S2),
+  score(allergicRhinitis, S3),
+  score(bacterialPneumonia, S4),
+  (A is S1 + S2),
+  (B is S3 + S4),
+  (Total is A + B).
+
+% Decimal surface values from the Eyeling reference output.
+score_decimal(covid19, 0.0015470000000000002).
+score_decimal(influenza, 0.000048000000000000015).
+score_decimal(allergicRhinitis, 7.499999999999999e-7).
+score_decimal(bacterialPneumonia, 0.000047879999999999996).
+
+total_score_decimal(0.0016436300000000003).
+
+posterior(covid19, 0.9412093962753174).
+posterior(influenza, 0.029203652890249024).
+posterior(allergicRhinitis, 0.00045630707641014084).
+posterior(bacterialPneumonia, 0.029130643758023392).
+
+scores(case, [
+  0.0015470000000000002,
+  0.000048000000000000015,
+  7.499999999999999e-7,
+  0.000047879999999999996
+]).
+evidenceTotal(case, Total) :- total_score_decimal(Total).
+result(case, result(Disease)) :- disease(Disease).
+disease(result(Disease), Disease) :- disease(Disease).
+unnormalized(result(Disease), Score) :- score_decimal(Disease, Score).
+posterior(result(Disease), Posterior) :- posterior(Disease, Posterior).

package/examples/bayes-therapy.pl

@@ -0,0 +1,197 @@
+% Memoize shared inference layers: the score vector, disease likelihood tails,
+% and expected therapy success are reused by several report relations.
+% Output declarations: host-supplied goals select the relations written to this example's golden output.
+%
+% Read this as two stacked inference problems: first infer disease posterior
+% probabilities from symptoms, then score each therapy by averaging outcomes
+% over that posterior distribution. The recursive predicates are
+% shared layers used by several queried reports.
+%% goal: diseases(X0, X1)
+
+%% goal: therapies(X0, X1)
+
+%% goal: evidence(X0, X1)
+
+%% goal: scores(X0, X1)
+
+%% goal: evidenceTotal(X0, X1)
+
+%% goal: posteriors(X0, X1)
+
+%% goal: posterior(X0, X1)
+
+%% goal: expectedSuccess(X0, X1)
+
+%% goal: expectedAdverse(X0, X1)
+
+%% goal: utility(X0, X1)
+
+%% goal: recommendedTherapy(X0, X1)
+
+
+% Program structure: facts set up the scenario, and rules derive the queried conclusions.
+
+% Bayes therapy decision support adapted from Eyeling bayes-therapy.n3.
+% Probabilities are illustrative and are not medical advice.
+% The example combines a tiny Naive Bayes diagnosis model with a therapy
+% utility layer: expected utility = 10 * expectedSuccess - 3 * expectedAdverse.
+
+diseases(case, [covid19, influenza, allergicRhinitis, bacterialPneumonia]).
+therapies(case, [paxlovid, oseltamivir, supportiveCare, antibiotic, antihistamine]).
+evidence(case, [
+  ev(fever, true),
+  ev(dryCough, true),
+  ev(lossOfSmell, false),
+  ev(sneezing, false),
+  ev(shortBreath, false)
+]).
+
+prior(covid19, 0.05).
+prior(influenza, 0.03).
+prior(allergicRhinitis, 0.10).
+prior(bacterialPneumonia, 0.01).
+
+p_given(covid19, fever, 0.70).
+p_given(covid19, dryCough, 0.65).
+p_given(covid19, lossOfSmell, 0.40).
+p_given(covid19, sneezing, 0.15).
+p_given(covid19, shortBreath, 0.20).
+
+p_given(influenza, fever, 0.80).
+p_given(influenza, dryCough, 0.50).
+p_given(influenza, lossOfSmell, 0.05).
+p_given(influenza, sneezing, 0.20).
+p_given(influenza, shortBreath, 0.10).
+
+p_given(allergicRhinitis, fever, 0.05).
+p_given(allergicRhinitis, dryCough, 0.15).
+p_given(allergicRhinitis, lossOfSmell, 0.10).
+p_given(allergicRhinitis, sneezing, 0.80).
+p_given(allergicRhinitis, shortBreath, 0.05).
+
+p_given(bacterialPneumonia, fever, 0.70).
+p_given(bacterialPneumonia, dryCough, 0.60).
+p_given(bacterialPneumonia, lossOfSmell, 0.02).
+p_given(bacterialPneumonia, sneezing, 0.05).
+p_given(bacterialPneumonia, shortBreath, 0.60).
+
+therapy(paxlovid).
+therapy(oseltamivir).
+therapy(antihistamine).
+therapy(antibiotic).
+therapy(supportiveCare).
+
+success_by_disease(paxlovid, [0.75, 0.05, 0.02, 0.05]).
+success_by_disease(oseltamivir, [0.05, 0.60, 0.02, 0.05]).
+success_by_disease(antihistamine, [0.10, 0.10, 0.75, 0.05]).
+success_by_disease(antibiotic, [0.05, 0.05, 0.02, 0.80]).
+success_by_disease(supportiveCare, [0.30, 0.30, 0.25, 0.20]).
+
+adverse(paxlovid, 0.10).
+adverse(oseltamivir, 0.08).
+adverse(antihistamine, 0.03).
+adverse(antibiotic, 0.07).
+adverse(supportiveCare, 0.01).
+
+benefit_weight(10).
+harm_weight(3).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+factor(Disease, ev(Symptom, true), P) :- p_given(Disease, Symptom, P).
+factor(Disease, ev(Symptom, false), Q) :-
+  p_given(Disease, Symptom, P),
+  (Q is 1.0 - P).
+
+likelihood(_disease, [], 1.0).
+likelihood(Disease, [Evidence|Rest], Likelihood) :-
+  factor(Disease, Evidence, Factor),
+  likelihood(Disease, Rest, Taillikelihood),
+  (Likelihood is Factor * Taillikelihood).
+
+% score/2 combines prior probability with the likelihood of the observed evidence.
+score(Disease, Score) :-
+  prior(Disease, Prior),
+  evidence(case, Evidence),
+  likelihood(Disease, Evidence, Likelihood),
+  (Score is Prior * Likelihood).
+
+scores_for([], []).
+scores_for([Disease|Restdiseases], [Score|Restscores]) :-
+  score(Disease, Score),
+  scores_for(Restdiseases, Restscores).
+
+score_sum([], 0.0).
+score_sum([Value|Rest], Sum) :-
+  score_sum(Rest, Tailsum),
+  (Sum is Value + Tailsum).
+
+normalize_scores([], _total, []).
+normalize_scores([Score|Restscores], Total, [Posterior|Restposteriors]) :-
+  (Posterior is Score / Total),
+  normalize_scores(Restscores, Total, Restposteriors).
+
+disease_posterior([Disease|_restdiseases], [Posterior|_restposteriors], Disease, Posterior).
+disease_posterior([_otherdisease|Restdiseases], [_otherposterior|Restposteriors], Disease, Posterior) :-
+  disease_posterior(Restdiseases, Restposteriors, Disease, Posterior).
+
+dot_product([], [], 0.0).
+dot_product([Left|Restleft], [Right|Restright], Sum) :-
+  (Term is Left * Right),
+  dot_product(Restleft, Restright, Tailsum),
+  (Sum is Term + Tailsum).
+
+expected_success(Therapy, Expectedsuccess) :-
+  posteriors(case, Posteriors),
+  success_by_disease(Therapy, Successbydisease),
+  dot_product(Posteriors, Successbydisease, Expectedsuccess).
+
+% utility/2 turns expected success and adverse effects into a ranking score.
+utility(Therapy, Utility) :-
+  expected_success(Therapy, Expectedsuccess),
+  adverse(Therapy, Adverse),
+  benefit_weight(Benefitweight),
+  harm_weight(Harmweight),
+  (Benefit is Benefitweight * Expectedsuccess),
+  (Harmcost is Harmweight * Adverse),
+  (Utility is Benefit - Harmcost).
+
+better_of(Therapy1, Therapy2, Therapy1) :-
+  utility(Therapy1, Utility1),
+  utility(Therapy2, Utility2),
+  (Utility1 >= Utility2).
+better_of(Therapy1, Therapy2, Therapy2) :-
+  utility(Therapy1, Utility1),
+  utility(Therapy2, Utility2),
+  (Utility1 < Utility2).
+
+best_therapy([Therapy], Therapy).
+best_therapy([Head, Next|Rest], Best) :-
+  best_therapy([Next|Rest], Bestrest),
+  better_of(Head, Bestrest, Best).
+
+scores(case, Scores) :-
+  diseases(case, Diseases),
+  scores_for(Diseases, Scores).
+evidenceTotal(case, Total) :-
+  scores(case, Scores),
+  score_sum(Scores, Total).
+posteriors(case, Posteriors) :-
+  scores(case, Scores),
+  evidenceTotal(case, Total),
+  normalize_scores(Scores, Total, Posteriors).
+posterior(Disease, Posterior) :-
+  diseases(case, Diseases),
+  posteriors(case, Posteriors),
+  disease_posterior(Diseases, Posteriors, Disease, Posterior).
+expectedSuccess(Therapy, Expectedsuccess) :-
+  therapy(Therapy),
+  expected_success(Therapy, Expectedsuccess).
+expectedAdverse(Therapy, Adverse) :-
+  therapy(Therapy),
+  adverse(Therapy, Adverse).
+utility(Therapy, Utility) :-
+  therapy(Therapy),
+  utility(Therapy, Utility).
+recommendedTherapy(case, Best) :-
+  therapies(case, Therapies),
+  best_therapy(Therapies, Best).

package/examples/beam-deflection.pl

@@ -0,0 +1,53 @@
+% Engineering example: cantilever beam tip deflection.
+% The beam is modeled with load, span length, elastic modulus, and second moment
+% of area.  The rules compute F*L^3/(3*E*I), convert meters to millimeters, and
+% classify the design against a deflection limit.
+
+%% goal: type(X0, X1)
+
+%% goal: tipDeflection_m(X0, X1)
+
+%% goal: tipDeflection_mm(X0, X1)
+
+%% goal: limit_mm(X0, X1)
+
+%% goal: status(X0, X1)
+
+
+beam(beam1, force_N, 1200.0).
+beam(beam1, length_m, 2.5).
+beam(beam1, elasticModulus_Pa, 200000000000.0).
+beam(beam1, secondMoment_m4, 0.000008).
+limit(beam1, maxDeflection_mm, 5.0).
+
+tip_deflection_m(Beam, Deflection) :-
+  beam(Beam, force_N, Force),
+  beam(Beam, length_m, Length),
+  beam(Beam, elasticModulus_Pa, Elasticmodulus),
+  beam(Beam, secondMoment_m4, Secondmoment),
+  (Lengthcubed is Length ** 3.0),
+  (Numerator is Force * Lengthcubed),
+  (Threee is 3.0 * Elasticmodulus),
+  (Denominator is Threee * Secondmoment),
+  (Deflection is Numerator / Denominator).
+
+tip_deflection_mm(Beam, Deflectionmm) :-
+  tip_deflection_m(Beam, Deflectionm),
+  (Deflectionmm is Deflectionm * 1000.0).
+
+type(Beam, cantilever_beam) :-
+  beam(Beam, force_N, _force).
+
+tipDeflection_m(Beam, Deflectionm) :-
+  tip_deflection_m(Beam, Deflectionm).
+
+tipDeflection_mm(Beam, Deflectionmm) :-
+  tip_deflection_mm(Beam, Deflectionmm).
+
+limit_mm(Beam, Limit) :-
+  limit(Beam, maxDeflection_mm, Limit).
+
+status(Beam, within_deflection_limit) :-
+  tip_deflection_mm(Beam, Deflectionmm),
+  limit(Beam, maxDeflection_mm, Limit),
+  (Deflectionmm =< Limit).

package/examples/binomial-vandermonde.pl

@@ -0,0 +1,49 @@
+% Binomial coefficients and Vandermonde's identity.
+%
+% choose(N,K,C) is computed by a multiplicative recurrence, then vandermonde/5 checks
+% the finite convolution sum: sum_i C(R,i) C(S,N-i) = C(R+S,N).  Memoization keeps
+% the binomial-row prefixes shared across both sides of the identity.
+% choose_step/5 uses the multiplicative recurrence
+%   C(N, I+1) = C(N, I) * (N-I) / (I+1)
+% and is cached automatically because row sums and identities reuse prefixes.
+%% goal: binomial_answer(X0, X1)
+
+
+
+choose(N, K, C) :-
+  (K >= 0),
+  (K =< N),
+  choose_step(N, K, 0, 1, C).
+
+choose_step(_n, K, K, Acc, Acc).
+choose_step(N, K, I, Acc, C) :-
+  (I < K),
+  (I1 is I + 1),
+  (Factor is N - I),
+  (Numerator is Acc * Factor),
+  (Nextacc is Numerator / I1),
+  choose_step(N, K, I1, Nextacc, C).
+
+symmetric(N, K) :-
+  choose(N, K, C),
+  (Otherk is N - K),
+  choose(N, Otherk, C).
+
+vandermonde_sum(N, M, R, Sum) :-
+  sumall(Product,
+    (between(0, R, K),
+     (Rk is R - K),
+     choose(N, K, A),
+     choose(M, Rk, B),
+     (Product is A * B)),
+    Sum).
+
+vandermonde(N, M, R, Sum) :-
+  (Totaln is N + M),
+  choose(Totaln, R, Sum),
+  vandermonde_sum(N, M, R, Sum).
+
+binomial_answer(choose_24_12, C) :- choose(24, 12, C).
+binomial_answer(symmetry_24_7, true) :- symmetric(24, 7).
+binomial_answer(vandermonde_12_10_8, Sum) :- vandermonde(12, 10, 8, Sum).
+binomial_answer(row_12_sum, Sum) :- sumall(C, (between(0, 12, K), choose(12, K, C)), Sum).

package/examples/blocks-world-planning.pl

@@ -0,0 +1,81 @@
+% Blocks-world planning without cut.
+%
+% A finite-depth planner searches for a five-move plan over five blocks.  States
+% are sorted lists of on(Block, Support) facts so equality and visited-state
+% checks are purely structural.
+
+% Output declarations: host-supplied goals select the relations written to this example's golden output.
+%% goal: status(X0, X1)
+
+%% goal: plan(X0, X1)
+
+%% goal: finalState(X0, X1)
+
+%% goal: blockCount(X0, X1)
+
+
+% The initial and goal states are lists of on/2 facts.  Sorting successor states
+% gives canonical terms for equality and visited-state checks.
+initial([on(a, table), on(b, a), on(c, b), on(d, c), on(e, d)]).
+goal([on(a, table), on(b, a), on(c, table), on(d, c), on(e, d)]).
+
+block(a).
+block(b).
+block(c).
+block(d).
+block(e).
+
+support(table, _state).
+% move/3 chooses a clear block and a clear support; the bounded planner chains
+% those legal moves while avoiding previously seen states.
+support(Block, State) :-
+  block(Block),
+  member(on(Block, _below), State).
+
+clear(Block, State) :-
+  \+ member(on(_other, Block), State).
+
+clear_support(table, _state).
+clear_support(Block, State) :-
+  block(Block),
+  clear(Block, State).
+
+move(State, move(Block, From, To), Newstate) :-
+  member(on(Block, From), State),
+  clear(Block, State),
+  support(To, State),
+  clear_support(To, State),
+  (Block \= To),
+  (From \= To),
+  select(on(Block, From), State, Rest),
+  sort([on(Block, To)|Rest], Newstate).
+
+plan(State, Goal, 0, _visited, [], State) :-
+  (State = Goal).
+
+plan(State, Goal, Depth, Visited, [Move|Moves], Final) :-
+  (Depth > 0),
+  move(State, Move, Next),
+  \+ member(Next, Visited),
+  (Restdepth is Depth - 1),
+  plan(Next, Goal, Restdepth, [Next|Visited], Moves, Final).
+
+five_move_plan(Moves, Final) :-
+  initial(Start),
+  goal(Goal),
+  sort(Start, Sortedstart),
+  sort(Goal, Sortedgoal),
+  plan(Sortedstart, Sortedgoal, 5, [Sortedstart], Moves, Final).
+
+status(blocks_world, planned) :-
+  once(five_move_plan(_moves, _final)).
+
+plan(blocks_world, Moves) :-
+  once(five_move_plan(Moves, _final)).
+
+finalState(blocks_world, Final) :-
+  once(five_move_plan(_moves, Final)).
+
+blockCount(blocks_world, Count) :-
+  findall(Block, block(Block), Blocks),
+  length(Blocks, Count).