eyelang 1.2.2 → 1.3.1

package/examples/braking-safety-worlds.pl

@@ -1,69 +0,0 @@
-% EYE reasoning-inspired example: braking safety in alternative worlds.
-%
-% Four simplified models classify the same road scenarios. The example is not a
-% real safety calculator; it demonstrates rule-level model comparison.
-
-% Output declarations: materialize/2 selects the relations written to this example's golden output.
-materialize(safeInWorld, 2).
-materialize(riskyInWorld, 2).
-materialize(status, 2).
-materialize(reason, 2).
-
-% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
-scenario(city_dry, 13.9, 0.8, 40.0).
-scenario(highway_dry_short_gap, 27.8, 0.8, 60.0).
-scenario(city_wet, 13.9, 0.4, 40.0).
-scenario(city_ice, 13.9, 0.2, 30.0).
-
-world(w0, "physics-based stopping distance with reaction time").
-world(w1, "simplified braking-only rule without reaction time").
-world(w2, "naive dry-road friction assumption").
-world(w3, "cautious factor over the physics model").
-
-% Derivation rules: each rule below contributes one logical step toward the displayed results.
-stop_distance(Scenario, w0, Distance) :-
-  scenario(Scenario, V, Mu, Avail),
-  mul(V, 1.0, Reaction),
-  pow(V, 2.0, V2),
-  mul(Mu, 2.0, M2),
-  mul(M2, 9.8, Denom),
-  div(V2, Denom, Braking),
-  add(Reaction, Braking, Distance).
-
-stop_distance(Scenario, w1, Distance) :-
-  scenario(Scenario, V, Mu, Avail),
-  pow(V, 2.0, V2),
-  mul(Mu, 2.0, M2),
-  mul(M2, 10.0, Denom),
-  div(V2, Denom, Distance).
-
-stop_distance(Scenario, w2, Distance) :-
-  scenario(Scenario, V, Mu, Avail),
-  pow(V, 2.0, V2),
-  div(V2, 14.0, Distance).
-
-stop_distance(Scenario, w3, Distance) :-
-  stop_distance(Scenario, w0, W0Distance),
-  mul(W0Distance, 1.5, Distance).
-
-safe_in_world(Scenario, World) :-
-  scenario(Scenario, V, Mu, Avail),
-  stop_distance(Scenario, World, Distance),
-  le(Distance, Avail).
-
-risky_in_world(Scenario, World) :-
-  scenario(Scenario, V, Mu, Avail),
-  stop_distance(Scenario, World, Distance),
-  gt(Distance, Avail).
-
-pattern_matches(report) :-
-  safe_in_world(city_dry, w0), safe_in_world(city_dry, w1), safe_in_world(city_dry, w2), safe_in_world(city_dry, w3),
-  risky_in_world(highway_dry_short_gap, w0), risky_in_world(highway_dry_short_gap, w3),
-  safe_in_world(highway_dry_short_gap, w1), safe_in_world(highway_dry_short_gap, w2),
-  safe_in_world(city_wet, w0), safe_in_world(city_wet, w1), safe_in_world(city_wet, w2), risky_in_world(city_wet, w3),
-  risky_in_world(city_ice, w0), risky_in_world(city_ice, w1), risky_in_world(city_ice, w3), safe_in_world(city_ice, w2).
-
-safeInWorld(Scenario, World) :- safe_in_world(Scenario, World).
-riskyInWorld(Scenario, World) :- risky_in_world(Scenario, World).
-status(braking_safety_worlds, expected_world_pattern) :- pattern_matches(report).
-reason(braking_safety_worlds, "simplified and naive worlds can be optimistic while the cautious world tightens the reference model") :- pattern_matches(report).

package/examples/buck-converter-design.pl

@@ -1,83 +0,0 @@
-% Engineering example: buck-converter ripple check.
-%
-% A simplified continuous-conduction buck converter model computes duty cycle,
-% inductor ripple current, capacitor ripple voltage, and checks design limits.
-
-% Output declarations: materialize/2 selects the relations written to this example's golden output.
-%
-% The constants describe one regulator design. The rules intentionally keep
-% each engineering equation separate so proof output can point to the exact
-% calculation that made the design pass or fail.
-materialize(dutyCycle, 2).
-materialize(inductorRipple_A, 2).
-materialize(rippleRatio, 2).
-materialize(capacitorRipple_V, 2).
-materialize(status, 2).
-materialize(reason, 2).
-
-% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
-converter(regulator1, inputVoltage_V, 24.0).
-converter(regulator1, outputVoltage_V, 5.0).
-converter(regulator1, loadCurrent_A, 2.0).
-converter(regulator1, switchingFrequency_Hz, 500000.0).
-converter(regulator1, inductance_H, 0.000022).
-converter(regulator1, capacitance_F, 0.000047).
-limit(regulator1, maxRippleRatio, 0.30).
-limit(regulator1, maxOutputRipple_V, 0.05).
-
-% Derivation rules: each rule below contributes one logical step toward the displayed results.
-duty_cycle(Converter, Duty) :-
-  converter(Converter, outputVoltage_V, OutputVoltage),
-  converter(Converter, inputVoltage_V, InputVoltage),
-  div(OutputVoltage, InputVoltage, Duty).
-
-inductor_ripple_current(Converter, RippleCurrent) :-
-  converter(Converter, inputVoltage_V, InputVoltage),
-  converter(Converter, outputVoltage_V, OutputVoltage),
-  converter(Converter, inductance_H, Inductance),
-  converter(Converter, switchingFrequency_Hz, Frequency),
-  duty_cycle(Converter, Duty),
-  sub(InputVoltage, OutputVoltage, VoltageAcrossInductor),
-  mul(VoltageAcrossInductor, Duty, Numerator),
-  mul(Inductance, Frequency, Denominator),
-  div(Numerator, Denominator, RippleCurrent).
-
-ripple_ratio(Converter, Ratio) :-
-  inductor_ripple_current(Converter, RippleCurrent),
-  converter(Converter, loadCurrent_A, LoadCurrent),
-  div(RippleCurrent, LoadCurrent, Ratio).
-
-capacitor_ripple_voltage(Converter, RippleVoltage) :-
-  inductor_ripple_current(Converter, RippleCurrent),
-  converter(Converter, switchingFrequency_Hz, Frequency),
-  converter(Converter, capacitance_F, Capacitance),
-  mul(8.0, Frequency, EightF),
-  mul(EightF, Capacitance, Denominator),
-  div(RippleCurrent, Denominator, RippleVoltage).
-
-% within_ripple_limits/1 is the design gate for ripple current and output voltage.
-within_ripple_limits(Converter) :-
-  ripple_ratio(Converter, Ratio),
-  limit(Converter, maxRippleRatio, MaxRatio),
-  lt(Ratio, MaxRatio),
-  capacitor_ripple_voltage(Converter, RippleVoltage),
-  limit(Converter, maxOutputRipple_V, MaxRippleVoltage),
-  lt(RippleVoltage, MaxRippleVoltage).
-
-dutyCycle(Converter, Duty) :-
-  duty_cycle(Converter, Duty).
-
-inductorRipple_A(Converter, RippleCurrent) :-
-  inductor_ripple_current(Converter, RippleCurrent).
-
-rippleRatio(Converter, Ratio) :-
-  ripple_ratio(Converter, Ratio).
-
-capacitorRipple_V(Converter, RippleVoltage) :-
-  capacitor_ripple_voltage(Converter, RippleVoltage).
-
-status(Converter, stable_ripple_design) :-
-  within_ripple_limits(Converter).
-
-reason(Converter, "inductor-current and output-voltage ripple are below design limits") :-
-  within_ripple_limits(Converter).

package/examples/cache-performance.pl

@@ -1,56 +0,0 @@
-% Technology example: cache performance summary.
-%
-% A service has cache hits and misses with different response latencies. The
-% rules compute hit rate and weighted average latency, then classify whether
-% the cache is effective.
-
-% Output declarations: materialize/2 selects the relations written to this example's golden output.
-materialize(hitRate, 2).
-materialize(averageLatency_ms, 2).
-materialize(status, 2).
-materialize(reason, 2).
-
-% cache_sample/5 contains hits, misses, and the two latency classes; threshold/3
-% contains the operational targets used by the status rule.
-cache_sample(api_cache, 8600.0, 1400.0, 5.0, 80.0).
-threshold(api_cache, minimum_hit_rate, 0.80).
-threshold(api_cache, maximum_average_latency_ms, 20.0).
-
-% The rules compute total requests, hit rate, and weighted latency before
-% applying both acceptance thresholds together.
-total_requests(Cache, Total) :-
-  cache_sample(Cache, Hits, Misses, _HitLatency, _MissLatency),
-  add(Hits, Misses, Total).
-
-hit_rate(Cache, Rate) :-
-  cache_sample(Cache, Hits, _Misses, _HitLatency, _MissLatency),
-  total_requests(Cache, Total),
-  div(Hits, Total, Rate).
-
-average_latency(Cache, Average) :-
-  cache_sample(Cache, Hits, Misses, HitLatency, MissLatency),
-  mul(Hits, HitLatency, HitCost),
-  mul(Misses, MissLatency, MissCost),
-  add(HitCost, MissCost, TotalCost),
-  total_requests(Cache, Total),
-  div(TotalCost, Total, Average).
-
-cache_effective(Cache) :-
-  hit_rate(Cache, Rate),
-  threshold(Cache, minimum_hit_rate, MinimumRate),
-  gt(Rate, MinimumRate),
-  average_latency(Cache, Average),
-  threshold(Cache, maximum_average_latency_ms, MaximumLatency),
-  lt(Average, MaximumLatency).
-
-hitRate(Cache, Rate) :-
-  hit_rate(Cache, Rate).
-
-averageLatency_ms(Cache, Average) :-
-  average_latency(Cache, Average).
-
-status(Cache, cache_effective) :-
-  cache_effective(Cache).
-
-reason(Cache, "hit rate is above target and average latency is below limit") :-
-  cache_effective(Cache).

package/examples/canary-release.pl

@@ -1,51 +0,0 @@
-% Technology example: canary release decision.
-%
-% A canary deployment is rolled back when its measured error rate exceeds the
-% allowed budget, even when latency is still acceptable.
-
-% Output declarations: materialize/2 selects the relations written to this example's golden output.
-materialize(errorRate, 2).
-materialize(p95Latency_ms, 2).
-materialize(latencyCheck, 2).
-materialize(status, 2).
-materialize(reason, 2).
-
-% canary/4 records request count, error count, and p95 latency; thresholds
-% make the rollout policy explicit data rather than constants hidden in rules.
-canary(canary42, 5000.0, 75.0, 180.0).
-threshold(canary42, maximum_error_rate, 0.01).
-threshold(canary42, maximum_p95_latency_ms, 200.0).
-
-% The latency and error-budget checks are independent so the final rollback
-% reason can point to the failing guard.
-error_rate(Release, Rate) :-
-  canary(Release, Requests, Errors, _P95Latency),
-  div(Errors, Requests, Rate).
-
-latency_ok(Release) :-
-  canary(Release, _Requests, _Errors, P95Latency),
-  threshold(Release, maximum_p95_latency_ms, Maximum),
-  lt(P95Latency, Maximum).
-
-error_budget_exceeded(Release) :-
-  error_rate(Release, Rate),
-  threshold(Release, maximum_error_rate, Maximum),
-  gt(Rate, Maximum).
-
-rollback_recommended(Release) :-
-  error_budget_exceeded(Release).
-
-errorRate(Release, Rate) :-
-  error_rate(Release, Rate).
-
-p95Latency_ms(Release, P95Latency) :-
-  canary(Release, _Requests, _Errors, P95Latency).
-
-latencyCheck(Release, ok) :-
-  latency_ok(Release).
-
-status(Release, rollback_recommended) :-
-  rollback_recommended(Release).
-
-reason(Release, "canary error rate exceeds the allowed budget") :-
-  rollback_recommended(Release).

package/examples/cat-koko.pl

@@ -1,24 +0,0 @@
-% Cat Koko, adapted from Eyeling's examples/cat-koko.n3.
-%
-% The Eyeling output contains two existential witnesses. eyelang has no blank
-% node constructor in the portable core, so this adaptation names those
-% witnesses sk_0 and sk_1.
-
-% Output declarations: materialize/2 selects the relations written to this example's golden output.
-materialize(type, 2).
-materialize(is, 2).
-
-% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
-animal(koko).
-
-witness(cat, sk_0).
-witness(british_short_hair, sk_1).
-
-% Derivation rules: each rule below contributes one logical step toward the displayed results.
-type(X, cat) :- animal(koko), witness(cat, X).
-type(X, british_short_hair) :- animal(koko), witness(british_short_hair, X).
-
-is(test, true) :-
-  type(X, cat),
-  type(Y, british_short_hair),
-  neq(X, Y).

package/examples/catalan-convolution.pl

@@ -1,37 +0,0 @@
-% Catalan numbers by memoized convolution.
-%
-% catalan(N,C) sums all splits of N-1 into left and right substructures.  The same
-% Catalan values appear in binary tree shapes, parenthesizations, and polygon
-% triangulations, shown here with small wrapper predicates.
-materialize(catalan_answer, 2).
-
-memoize(catalan, 2).
-
-% C_0 = 1; higher values are computed by the convolution sum.
-catalan(0, 1).
-catalan(N, C) :-
-  gt(N, 0),
-  sub(N, 1, N1),
-  sumall(Product,
-    (between(0, N1, I),
-     sub(N1, I, J),
-     catalan(I, A),
-     catalan(J, B),
-     mul(A, B, Product)),
-    C).
-
-% An n-gon has C_(n-2) triangulations.
-polygon_triangulations(Sides, Count) :-
-  ge(Sides, 3),
-  sub(Sides, 2, N),
-  catalan(N, Count).
-
-parenthesizations(Factors, Count) :-
-  ge(Factors, 1),
-  sub(Factors, 1, N),
-  catalan(N, Count).
-
-catalan_answer(catalan_12, C) :- catalan(12, C).
-catalan_answer(triangulations_14_gon, Count) :- polygon_triangulations(14, Count).
-catalan_answer(parenthesizations_13_factors, Count) :- parenthesizations(13, Count).
-catalan_answer(first_ten_sum, Sum) :- sumall(C, (between(0, 9, N), catalan(N, C)), Sum).

package/examples/chart-parser.pl

@@ -1,65 +0,0 @@
-% A tiny memoized chart parser for a context-free grammar.
-%
-% span(Sentence, Category, Start, End) is the dynamic-programming chart item:
-% Category covers a half-open token interval.  Memoizing span/4 turns recursive
-% grammar recognition into chart parsing, so ambiguous phrases share subparses.
-materialize(chart_parser_answer, 2).
-
-memoize(span, 4).
-
-% Two sample sentences share the same tiny grammar but have different parse counts.
-
-sentence(command, 5).
-sentence(ambiguous_pp, 8).
-
-word(command, 0, the).
-word(command, 1, robot).
-word(command, 2, moves).
-word(command, 3, the).
-word(command, 4, box).
-
-word(ambiguous_pp, 0, the).
-word(ambiguous_pp, 1, robot).
-word(ambiguous_pp, 2, sees).
-word(ambiguous_pp, 3, the).
-word(ambiguous_pp, 4, box).
-word(ambiguous_pp, 5, with).
-word(ambiguous_pp, 6, the).
-word(ambiguous_pp, 7, telescope).
-
-terminal(det, the).
-terminal(noun, robot).
-terminal(noun, box).
-terminal(noun, telescope).
-terminal(verb, moves).
-terminal(verb, sees).
-terminal(prep, with).
-
-rule(s, np, vp).
-rule(np, det, noun).
-rule(np, np, pp).
-rule(vp, verb, np).
-rule(vp, vp, pp).
-rule(pp, prep, np).
-
-% Lexical chart items come directly from words and terminal categories.
-span(Sentence, Category, Start, End) :-
-  word(Sentence, Start, Token),
-  terminal(Category, Token),
-  add(Start, 1, End).
-% Nonterminal chart items split the interval at a Middle point.
-span(Sentence, Category, Start, End) :-
-  rule(Category, Left, Right),
-  span(Sentence, Left, Start, Middle),
-  span(Sentence, Right, Middle, End).
-
-chart_parser_answer(parsed, Sentence) :-
-  sentence(Sentence, Length),
-  span(Sentence, s, 0, Length).
-chart_parser_answer(parse_count, count(Sentence, Count)) :-
-  sentence(Sentence, Length),
-  countall(span(Sentence, s, 0, Length), Count).
-chart_parser_answer(noun_phrase_count, count(Sentence, Count)) :-
-  sentence(Sentence, Length),
-  countall(span(Sentence, np, _Start, _End), Count),
-  gt(Length, 0).

package/examples/clinical-trial-screening.pl

@@ -1,97 +0,0 @@
-% Representative example: clinical-trial screening.
-%
-% The program models a small diabetes trial screening workflow. Helper
-% predicates keep the inclusion/exclusion logic separate from the concise
-% public relation report.
-
-% Output declarations: materialize/2 selects the relations written to this example's golden output.
-%
-% Inclusion criteria are positive requirements; exclusion criteria veto a
-% candidate even when the inclusion checks pass. The emitted reason/2 facts are
-% the audit trail a coordinator would need for a screen-failure report.
-materialize(type, 2).
-materialize(status, 2).
-materialize(reason, 2).
-
-% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
-patient(p001).
-patient(p002).
-patient(p003).
-patient(p004).
-
-age(p001, 54).
-age(p002, 67).
-age(p003, 31).
-age(p004, 45).
-
-diagnosis(p001, type2_diabetes).
-diagnosis(p002, type2_diabetes).
-diagnosis(p003, type2_diabetes).
-diagnosis(p004, type2_diabetes).
-
-lab(p001, hba1c_pct, 8.4).
-lab(p002, hba1c_pct, 7.9).
-lab(p003, hba1c_pct, 9.1).
-lab(p004, hba1c_pct, 6.4).
-
-lab(p001, egfr_ml_min, 83.0).
-lab(p002, egfr_ml_min, 38.0).
-lab(p003, egfr_ml_min, 91.0).
-lab(p004, egfr_ml_min, 72.0).
-
-condition(p003, pregnant).
-
-% Derivation rules: each rule below contributes one logical step toward the displayed results.
-inclusion_adult(Patient) :-
-  patient(Patient),
-  age(Patient, Age),
-  ge(Age, 18).
-
-inclusion_diagnosis(Patient) :-
-  diagnosis(Patient, type2_diabetes).
-
-inclusion_hba1c(Patient) :-
-  lab(Patient, hba1c_pct, Hba1c),
-  ge(Hba1c, 7.0),
-  le(Hba1c, 10.5).
-
-exclusion_renal(Patient) :-
-  lab(Patient, egfr_ml_min, Egfr),
-  lt(Egfr, 45.0).
-
-exclusion_pregnancy(Patient) :-
-  condition(Patient, pregnant).
-
-% A patient is eligible only when all inclusion checks pass and no exclusion is proven.
-screen_eligible(Patient) :-
-  inclusion_adult(Patient),
-  inclusion_diagnosis(Patient),
-  inclusion_hba1c(Patient),
-  not(exclusion_renal(Patient)),
-  not(exclusion_pregnancy(Patient)).
-
-screen_fail(Patient) :- exclusion_renal(Patient).
-screen_fail(Patient) :- exclusion_pregnancy(Patient).
-screen_fail(Patient) :- patient(Patient), not(inclusion_hba1c(Patient)).
-
-type(Patient, trial_candidate) :-
-  screen_eligible(Patient).
-
-status(Patient, eligible) :-
-  screen_eligible(Patient).
-
-reason(Patient, "meets inclusion criteria and no listed exclusion") :-
-  screen_eligible(Patient).
-
-status(Patient, screen_fail) :-
-  screen_fail(Patient).
-
-reason(Patient, "eGFR below renal safety threshold") :-
-  exclusion_renal(Patient).
-
-reason(Patient, "pregnancy exclusion applies") :-
-  exclusion_pregnancy(Patient).
-
-reason(Patient, "HbA1c is outside protocol range") :-
-  patient(Patient),
-  not(inclusion_hba1c(Patient)).

package/examples/collatz-1000.pl

@@ -1,45 +0,0 @@
-% Collatz conjecture suite translated from Eyeling's examples/collatz-1000.n3.
-% It enumerates starts N = 1000, 999, ..., 1 by deriving N = 1000 - N0
-% from a repeat relation, then materializes each full trajectory.
-%
-% Source N3:
-% https://raw.githubusercontent.com/eyereasoner/eyeling/refs/heads/main/examples/collatz-1000.n3
-
-% Output declarations: materialize/2 selects the relations written to this example's golden output.
-% memoize/2 caches shared suffix trajectories so the 1000 starts do not recompute
-% the same Collatz tails hundreds of times.
-materialize(collatzTrajectory, 2).
-memoize(collatz, 2).
-
-% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
-% The N3 source defines repeat/2 recursively; this Eyelang version uses the
-% equivalent bounded generator so the 1000-case regression remains stack-safe.
-
-% Query / materialization of the test suite.
-% Generate N in {1000..1} and ask the backward-defined collatz/2 predicate
-% for the full trajectory list M.
-collatzTrajectory(N, M) :-
-  repeat(1000, N0),
-  sub(1000, N0, N),
-  collatz(N, M).
-
-% Range generator.
-% repeat(N, I) enumerates all integers I in the half-open interval [0..N-1].
-repeat(N, I) :-
-  sub(N, 1, Last),
-  between(0, Last, I).
-
-% Backward Collatz relation.
-% collatz(N, M) relates a start value N to its full trajectory list M.
-collatz(1, [1]).
-collatz(N, [N|J]) :-
-  gt(N, 1),
-  mod(N, 2, 0),
-  div(N, 2, N1),
-  collatz(N1, J).
-collatz(N, [N|J]) :-
-  gt(N, 1),
-  mod(N, 2, 1),
-  mul(3, N, T),
-  add(T, 1, N1),
-  collatz(N1, J).

package/examples/combinatorics-findall-sort.pl

@@ -1,38 +0,0 @@
-% Eyelet-inspired combinations example using findall/3 and sort/2.
-%
-% combination/3 generates the same subset in several selection orders.  findall/3
-% collects those candidates, and sort/2 canonicalizes the list so each unordered
-% 3-combination of five items is reported once.
-materialize(combinations, 2).
-materialize(count, 2).
-materialize(reason, 2).
-
-% select/3 nondeterministically removes one item from a list; because it is an
-% ordinary rule, the example also demonstrates user-level list recursion.
-select(Item, [Item | Rest], Rest).
-% The recursive clause keeps the non-selected head and searches the tail.
-select(Item, [Head | Tail], [Head | Rest]) :-
-  select(Item, Tail, Rest).
-
-% combination/3 builds an unordered K-combination by repeated selection.
-combination(0, _Items, []).
-combination(I, Items, Combination) :-
-  gt(I, 0),
-  select(Item, Items, Remaining),
-  sub(I, 1, J),
-  combination(J, Remaining, Partial),
-  sort([Item | Partial], Combination).
-
-% findall collects all generation orders; sort canonicalizes and deduplicates.
-unique_combinations(K, Items, Unique) :-
-  findall(C, combination(K, Items, C), All),
-  sort(All, Unique).
-
-combinations(combinations_5_choose_3, Unique) :-
-  unique_combinations(3, [1, 2, 3, 4, 5], Unique).
-
-count(combinations_5_choose_3, Count) :-
-  unique_combinations(3, [1, 2, 3, 4, 5], Unique),
-  length(Unique, Count).
-
-reason(combinations_5_choose_3, "findall gathers generated combinations and sort removes duplicates").

package/examples/competitive-enzyme-kinetics.pl

@@ -1,78 +0,0 @@
-% Science example: competitive enzyme inhibition.
-%
-% Michaelis-Menten kinetics with a competitive inhibitor:
-%   Km_effective = Km * (1 + Inhibitor / Ki)
-%   rate = Vmax * Substrate / (Km_effective + Substrate)
-
-% Output declarations: materialize/2 selects the relations written to this example's golden output.
-materialize(effectiveKm_uM, 2).
-materialize(uninhibitedRate_uM_s, 2).
-materialize(inhibitedRate_uM_s, 2).
-materialize(inhibitionFraction, 2).
-materialize(status, 2).
-materialize(reason, 2).
-
-% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
-assay(assay1, vmax_uM_s, 120.0).
-assay(assay1, substrate_uM, 50.0).
-assay(assay1, km_uM, 30.0).
-assay(assay1, inhibitor_uM, 10.0).
-assay(assay1, ki_uM, 5.0).
-threshold(assay1, significant_inhibition_fraction, 0.25).
-
-% Derivation rules: each rule below contributes one logical step toward the displayed results.
-competitive_multiplier(Assay, Multiplier) :-
-  assay(Assay, inhibitor_uM, Inhibitor),
-  assay(Assay, ki_uM, Ki),
-  div(Inhibitor, Ki, Ratio),
-  add(1.0, Ratio, Multiplier).
-
-effective_km(Assay, EffectiveKm) :-
-  assay(Assay, km_uM, Km),
-  competitive_multiplier(Assay, Multiplier),
-  mul(Km, Multiplier, EffectiveKm).
-
-uninhibited_rate(Assay, Rate) :-
-  assay(Assay, vmax_uM_s, Vmax),
-  assay(Assay, substrate_uM, Substrate),
-  assay(Assay, km_uM, Km),
-  mul(Vmax, Substrate, Numerator),
-  add(Km, Substrate, Denominator),
-  div(Numerator, Denominator, Rate).
-
-inhibited_rate(Assay, Rate) :-
-  assay(Assay, vmax_uM_s, Vmax),
-  assay(Assay, substrate_uM, Substrate),
-  effective_km(Assay, EffectiveKm),
-  mul(Vmax, Substrate, Numerator),
-  add(EffectiveKm, Substrate, Denominator),
-  div(Numerator, Denominator, Rate).
-
-inhibition_fraction(Assay, Fraction) :-
-  uninhibited_rate(Assay, Uninhibited),
-  inhibited_rate(Assay, Inhibited),
-  sub(Uninhibited, Inhibited, Delta),
-  div(Delta, Uninhibited, Fraction).
-
-significant_inhibition(Assay) :-
-  inhibition_fraction(Assay, Fraction),
-  threshold(Assay, significant_inhibition_fraction, Limit),
-  gt(Fraction, Limit).
-
-effectiveKm_uM(Assay, EffectiveKm) :-
-  effective_km(Assay, EffectiveKm).
-
-uninhibitedRate_uM_s(Assay, Rate) :-
-  uninhibited_rate(Assay, Rate).
-
-inhibitedRate_uM_s(Assay, Rate) :-
-  inhibited_rate(Assay, Rate).
-
-inhibitionFraction(Assay, Fraction) :-
-  inhibition_fraction(Assay, Fraction).
-
-status(Assay, significant_inhibition) :-
-  significant_inhibition(Assay).
-
-reason(Assay, "competitive inhibitor raises effective Km and lowers reaction rate") :-
-  significant_inhibition(Assay).