eyelang 0.1.0

package/examples/braking-safety-worlds.pl

@@ -0,0 +1,69 @@
+% 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

@@ -0,0 +1,78 @@
+% 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.
+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(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

@@ -0,0 +1,54 @@
+% 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).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+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).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+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

@@ -0,0 +1,49 @@
+% 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).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+canary(canary42, 5000.0, 75.0, 180.0).
+threshold(canary42, maximum_error_rate, 0.01).
+threshold(canary42, maximum_p95_latency_ms, 200.0).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+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

@@ -0,0 +1,24 @@
+% 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/clinical-trial-screening.pl

@@ -0,0 +1,92 @@
+% 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.
+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).
+
+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/combinatorics-findall-sort.pl

@@ -0,0 +1,37 @@
+% Eyelet-inspired combinations example using findall/3 and sort/2.
+% The source-level select/3 relation remains an ordinary eyelang rule.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(combinations, 2).
+materialize(count, 2).
+materialize(reason, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+% select/3 nondeterministically removes one item from a list.
+select(Item, [Item | Rest], Rest).
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+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

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

package/examples/complex.pl

@@ -0,0 +1,121 @@
+% 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.
+materialize(is, 2).
+
+% 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.
+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).
+
+is(test, (
+  complex_exponentiation(input(exponentiation, [-1, 0], [0.5, 0]), C1),
+  complex_exponentiation(input(exponentiation, [2.718281828459045, 0], [0, 3.141592653589793]), C2),
+  complex_exponentiation(input(exponentiation, [0, 1], [0, 1]), C3),
+  complex_exponentiation(input(exponentiation, [2.718281828459045, 0], [-1.57079632679, 0]), C4),
+  complex_asin(input(asin, [2, 0]), C5),
+  complex_acos(input(acos, [2, 0]), C6)
+)) :-
+  complex_exponentiation([-1, 0], [0.5, 0], C1),
+  complex_exponentiation([2.718281828459045, 0], [0, 3.141592653589793], C2),
+  complex_exponentiation([0, 1], [0, 1], C3),
+  complex_exponentiation([2.718281828459045, 0], [-1.57079632679, 0], C4),
+  complex_asin([2, 0], C5),
+  complex_acos([2, 0], C6).

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

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