eyelang 0.1.0

package/examples/proof/proof-contrapositive.pl

@@ -0,0 +1,78 @@
+refutes(proof1, raining).
+why(
+  refutes(proof1, raining),
+  proof(
+    goal(refutes(proof1, raining)),
+    by(rule("proof-contrapositive.pl", clause(7))),
+    uses([
+      proof(
+        goal(false(raining)),
+        by(rule("proof-contrapositive.pl", clause(6))),
+        bindings([binding("A", raining), binding("B", wet_ground)]),
+        uses([
+          proof(
+            goal(implies(raining, wet_ground)),
+            by(fact("proof-contrapositive.pl", clause(4)))
+          ),
+          proof(
+            goal(false(wet_ground)),
+            by(fact("proof-contrapositive.pl", clause(5)))
+          )
+        ])
+      )
+    ])
+  )
+).
+
+method(proof1, contrapositive).
+why(
+  method(proof1, contrapositive),
+  proof(
+    goal(method(proof1, contrapositive)),
+    by(rule("proof-contrapositive.pl", clause(8))),
+    uses([
+      proof(
+        goal(false(raining)),
+        by(rule("proof-contrapositive.pl", clause(6))),
+        bindings([binding("A", raining), binding("B", wet_ground)]),
+        uses([
+          proof(
+            goal(implies(raining, wet_ground)),
+            by(fact("proof-contrapositive.pl", clause(4)))
+          ),
+          proof(
+            goal(false(wet_ground)),
+            by(fact("proof-contrapositive.pl", clause(5)))
+          )
+        ])
+      )
+    ])
+  )
+).
+
+reason(proof1, "if rain implies wet ground and the ground is not wet, then it is not raining").
+why(
+  reason(proof1, "if rain implies wet ground and the ground is not wet, then it is not raining"),
+  proof(
+    goal(reason(proof1, "if rain implies wet ground and the ground is not wet, then it is not raining")),
+    by(rule("proof-contrapositive.pl", clause(9))),
+    uses([
+      proof(
+        goal(false(raining)),
+        by(rule("proof-contrapositive.pl", clause(6))),
+        bindings([binding("A", raining), binding("B", wet_ground)]),
+        uses([
+          proof(
+            goal(implies(raining, wet_ground)),
+            by(fact("proof-contrapositive.pl", clause(4)))
+          ),
+          proof(
+            goal(false(wet_ground)),
+            by(fact("proof-contrapositive.pl", clause(5)))
+          )
+        ])
+      )
+    ])
+  )
+).
+

package/examples/proof/socket-age.pl

@@ -0,0 +1,32 @@
+ageAbove(patH, "P80Y").
+why(
+  ageAbove(patH, "P80Y"),
+  proof(
+    goal(ageAbove(patH, "P80Y")),
+    by(rule("socket-age.pl", clause(11))),
+    bindings([binding("S", patH), binding("A", "P80Y"), binding("B", "1944-08-21"), binding("D", "2026-05-30"), binding("F", "P81Y9M9D")]),
+    uses([
+      proof(
+        goal(birthDay(patH, "1944-08-21")),
+        by(fact("socket-age.pl", clause(8)))
+      ),
+      proof(
+        goal(duration(check, "P80Y")),
+        by(fact("socket-age.pl", clause(9)))
+      ),
+      proof(
+        goal(today("2026-05-30")),
+        by(fact("socket-age.pl", clause(10)))
+      ),
+      proof(
+        goal(difference("2026-05-30", "1944-08-21", "P81Y9M9D")),
+        by(builtin(difference, 3))
+      ),
+      proof(
+        goal(gt("P81Y9M9D", "P80Y")),
+        by(builtin(gt, 2))
+      )
+    ])
+  )
+).
+

package/examples/proof/socket-family.pl

@@ -0,0 +1,59 @@
+ancestor(pat, jan).
+why(
+  ancestor(pat, jan),
+  proof(
+    goal(ancestor(pat, jan)),
+    by(rule("socket-family.pl", clause(6))),
+    bindings([binding("X", pat), binding("Y", jan)]),
+    uses([
+      proof(
+        goal(parent(pat, jan)),
+        by(fact("socket-family.pl", clause(4)))
+      )
+    ])
+  )
+).
+
+ancestor(jan, emma).
+why(
+  ancestor(jan, emma),
+  proof(
+    goal(ancestor(jan, emma)),
+    by(rule("socket-family.pl", clause(6))),
+    bindings([binding("X", jan), binding("Y", emma)]),
+    uses([
+      proof(
+        goal(parent(jan, emma)),
+        by(fact("socket-family.pl", clause(5)))
+      )
+    ])
+  )
+).
+
+ancestor(pat, emma).
+why(
+  ancestor(pat, emma),
+  proof(
+    goal(ancestor(pat, emma)),
+    by(rule("socket-family.pl", clause(7))),
+    bindings([binding("X", pat), binding("Z", emma), binding("Y", jan)]),
+    uses([
+      proof(
+        goal(parent(pat, jan)),
+        by(fact("socket-family.pl", clause(4)))
+      ),
+      proof(
+        goal(ancestor(jan, emma)),
+        by(rule("socket-family.pl", clause(6))),
+        bindings([binding("X", jan), binding("Y", emma)]),
+        uses([
+          proof(
+            goal(parent(jan, emma)),
+            by(fact("socket-family.pl", clause(5)))
+          )
+        ])
+      )
+    ])
+  )
+).
+

package/examples/proof/socrates.pl

@@ -0,0 +1,38 @@
+type(socrates, mortal).
+why(
+  type(socrates, mortal),
+  proof(
+    goal(type(socrates, mortal)),
+    by(rule("socrates.pl", clause(4))),
+    bindings([binding("X", socrates)]),
+    uses([
+      proof(
+        goal(type(socrates, man)),
+        by(fact("socrates.pl", clause(3)))
+      )
+    ])
+  )
+).
+
+is(test, true).
+why(
+  is(test, true),
+  proof(
+    goal(is(test, true)),
+    by(rule("socrates.pl", clause(5))),
+    uses([
+      proof(
+        goal(type(socrates, mortal)),
+        by(rule("socrates.pl", clause(4))),
+        bindings([binding("X", socrates)]),
+        uses([
+          proof(
+            goal(type(socrates, man)),
+            by(fact("socrates.pl", clause(3)))
+          )
+        ])
+      )
+    ])
+  )
+).
+

package/examples/proof-contrapositive.pl

@@ -0,0 +1,27 @@
+% Proof by contrapositive example adapted from Eyelet input/proof-by-contrapositive.pl.
+%
+% The implication itself is represented as data with implies/2.  The proof
+% rule remains ordinary eyelang: if A implies B and B is false, then A is false.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(refutes, 2).
+materialize(method, 2).
+materialize(reason, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+implies(raining, wet_ground).
+false(wet_ground).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+false(A) :-
+  implies(A, B),
+  false(B).
+
+refutes(proof1, raining) :-
+  false(raining).
+
+method(proof1, contrapositive) :-
+  false(raining).
+
+reason(proof1, "if rain implies wet ground and the ground is not wet, then it is not raining") :-
+  false(raining).

package/examples/quadratic-formula.pl

@@ -0,0 +1,54 @@
+% Quadratic formula over sample equations.
+%
+% Each equation is represented as a*x^2 + b*x + c = 0.  The example uses
+% eyelang arithmetic predicates to derive the discriminant and the two roots.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(discriminant, 2).
+materialize(root, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+equation(eq1, 1.0, -5.0, 6.0).
+equation(eq2, 2.0, -4.0, -6.0).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+discriminant(Case, D) :-
+  equation(Case, A, B, C),
+  pow(B, 2.0, B2),
+  mul(4.0, A, FourA),
+  mul(FourA, C, FourAC),
+  sub(B2, FourAC, D).
+
+sqrt_discriminant(Case, S) :-
+  discriminant(Case, D),
+  ge(D, 0.0),
+  pow(D, 0.5, S).
+
+negative_b(Case, NB) :-
+  equation(Case, _A, B, _C),
+  neg(B, NB).
+
+denominator(Case, Den) :-
+  equation(Case, A, _B, _C),
+  mul(2.0, A, Den).
+
+root_plus(Case, Root) :-
+  negative_b(Case, NB),
+  sqrt_discriminant(Case, S),
+  denominator(Case, Den),
+  add(NB, S, Numerator),
+  div(Numerator, Den, Root).
+
+root_minus(Case, Root) :-
+  negative_b(Case, NB),
+  sqrt_discriminant(Case, S),
+  denominator(Case, Den),
+  sub(NB, S, Numerator),
+  div(Numerator, Den, Root).
+
+
+root(Case, Root) :-
+  root_plus(Case, Root).
+
+root(Case, Root) :-
+  root_minus(Case, Root).

package/examples/radioactive-decay.pl

@@ -0,0 +1,56 @@
+% Science example: radioactive decay.
+%
+% Activity remaining after elapsed time is initial_activity * 0.5^(t/half_life).
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(halfLivesElapsed, 2).
+materialize(remainingActivity_Bq, 2).
+materialize(decayedActivity_Bq, 2).
+materialize(status, 2).
+materialize(reason, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+sample(iodine_sample, initial_activity_bq, 80.0).
+sample(iodine_sample, half_life_h, 8.0).
+sample(iodine_sample, elapsed_h, 16.0).
+threshold(iodine_sample, low_activity_bq, 25.0).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+half_lives(Sample, Count) :-
+  sample(Sample, elapsed_h, Elapsed),
+  sample(Sample, half_life_h, HalfLife),
+  div(Elapsed, HalfLife, Count).
+
+remaining_fraction(Sample, Fraction) :-
+  half_lives(Sample, Count),
+  pow(0.5, Count, Fraction).
+
+remaining_activity(Sample, Remaining) :-
+  sample(Sample, initial_activity_bq, Initial),
+  remaining_fraction(Sample, Fraction),
+  mul(Initial, Fraction, Remaining).
+
+decayed_activity(Sample, Decayed) :-
+  sample(Sample, initial_activity_bq, Initial),
+  remaining_activity(Sample, Remaining),
+  sub(Initial, Remaining, Decayed).
+
+low_activity(Sample) :-
+  remaining_activity(Sample, Remaining),
+  threshold(Sample, low_activity_bq, Limit),
+  lt(Remaining, Limit).
+
+halfLivesElapsed(Sample, Count) :-
+  half_lives(Sample, Count).
+
+remainingActivity_Bq(Sample, Remaining) :-
+  remaining_activity(Sample, Remaining).
+
+decayedActivity_Bq(Sample, Decayed) :-
+  decayed_activity(Sample, Decayed).
+
+status(Sample, low_activity) :-
+  low_activity(Sample).
+
+reason(Sample, "two half-lives leave one quarter of the initial activity") :-
+  low_activity(Sample).

package/examples/reusable-builtins.pl

@@ -0,0 +1,32 @@
+% Reusable builtin tour: normalize text, summarize lists, and compute numeric values.
+materialize(report, 2).
+
+name_raw("  Ada Lovelace  ").
+tag_csv("logic,math,logic,programming").
+scores([8, 13, 21]).
+
+report(normalized_name, Name) :-
+  name_raw(Raw),
+  trim(Raw, Trimmed),
+  lowercase(Trimmed, Name).
+
+report(unique_tags, Tags) :-
+  tag_csv(Csv),
+  split(Csv, ",", Parts),
+  list_to_set(Parts, Tags).
+
+report(tag_label, Label) :-
+  tag_csv(Csv),
+  split(Csv, ",", Parts),
+  list_to_set(Parts, Tags),
+  join(Tags, " / ", Label).
+
+report(score_summary, summary(Total, Peak, RootTotal)) :-
+  scores(Scores),
+  sum_list(Scores, Total),
+  max_list(Scores, Peak),
+  sqrt(Total, RootTotal).
+
+report(window, Slice) :-
+  scores(Scores),
+  slice(1, 2, Scores, Slice).

package/examples/riemann-hypothesis.pl

@@ -0,0 +1,110 @@
+% Riemann hypothesis, as a finite eyelang check.
+%
+% This example does not prove the Riemann hypothesis.  It models the
+% finite statement: every non-trivial zero in the local catalogue has
+% real part 0.5.  A real proof would have to cover all non-trivial zeros,
+% not only the facts listed here.
+
+% Print the finite check summary and the per-zero audit rows.
+materialize(rh, 2).
+materialize(zero_check, 3).
+
+% --- Sample zero catalogue -------------------------------------------------
+%
+% The three z* entries stand for catalogued non-trivial zeros of the
+% Riemann zeta function.  The t* entry is a trivial zero, included to show
+% that the rules below deliberately exclude it from the RH check.
+
+zeta_zero(z1).
+real_part(z1, 0.5).
+imaginary_part(z1, 14.134725).
+source(z1, "first catalogued non-trivial zero in this example").
+
+zeta_zero(z2).
+real_part(z2, 0.5).
+imaginary_part(z2, 21.02204).
+source(z2, "second catalogued non-trivial zero in this example").
+
+zeta_zero(z3).
+real_part(z3, 0.5).
+imaginary_part(z3, 25.010858).
+source(z3, "third catalogued non-trivial zero in this example").
+
+zeta_zero(t1).
+trivial_zero(t1).
+real_part(t1, -2).
+imaginary_part(t1, 0).
+source(t1, "trivial zero, outside the non-trivial RH check").
+
+% --- Classification rules --------------------------------------------------
+%
+% A non-trivial zero is one of the catalogued zeta zeros that lies in the
+% critical strip 0 < real part < 1 and is not explicitly marked as trivial.
+
+in_critical_strip(Zero) :-
+  real_part(Zero, Real),
+  gt(Real, 0),
+  lt(Real, 1).
+
+non_trivial_zero(Zero) :-
+  zeta_zero(Zero),
+  in_critical_strip(Zero),
+  not(trivial_zero(Zero)).
+
+% The RH condition for one zero: its real part is exactly one half.
+
+on_critical_line(Zero) :-
+  non_trivial_zero(Zero),
+  real_part(Zero, 0.5).
+
+% A finite counterexample would be a catalogued non-trivial zero whose real
+% part is not one half.
+
+off_critical_line(Zero) :-
+  non_trivial_zero(Zero),
+  real_part(Zero, Real),
+  neq(Real, 0.5).
+
+catalog_has(non_trivial_zero) :-
+  non_trivial_zero(_SomeZero).
+
+counterexample_found(yes) :-
+  off_critical_line(_Zero).
+
+% The finite catalogue supports RH exactly when it contains at least one
+% non-trivial zero and no catalogued counterexample.
+
+finite_catalog_supports_rh(yes) :-
+  catalog_has(non_trivial_zero),
+  not(counterexample_found(yes)).
+
+% --- Materialized audit output --------------------------------------------
+
+% These tiny support facts make the summary rows derived output rather than
+% source facts; eyelang intentionally does not reprint source facts.
+
+summary_row(scope, finite_catalog_only).
+summary_row(caveat, "finite catalogue evidence only; this is not a proof of RH").
+
+rh(Key, Value) :-
+  summary_row(Key, Value).
+
+rh(status, no_counterexample_in_catalog) :-
+  finite_catalog_supports_rh(yes).
+
+rh(status, counterexample_in_catalog) :-
+  counterexample_found(yes).
+
+zero_check(Zero, real_part, Real) :-
+  non_trivial_zero(Zero),
+  real_part(Zero, Real).
+
+zero_check(Zero, imaginary_part, Imaginary) :-
+  non_trivial_zero(Zero),
+  imaginary_part(Zero, Imaginary).
+
+zero_check(Zero, classification, on_critical_line) :-
+  on_critical_line(Zero).
+
+zero_check(Zero, classification, off_critical_line) :-
+  off_critical_line(Zero).

package/examples/security-incident-correlation.pl

@@ -0,0 +1,69 @@
+% Representative example: security incident correlation.
+%
+% The rules correlate endpoint, identity, vulnerability, and threat-intelligence
+% signals into an escalation decision with concise reason relations.
+
+% 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.
+incident(inc42).
+incident(inc43).
+
+asset(endpoint23, criticality, high).
+asset(endpoint77, criticality, low).
+
+assigned_user(endpoint23, user_alice).
+assigned_user(endpoint77, user_bob).
+
+privileged_user(user_alice).
+
+alert(inc42, endpoint, endpoint23).
+alert(inc42, suspicious_login, user_alice).
+alert(inc42, malware_hash, hash_redline).
+alert(inc42, outbound_ip, ip_203_0_113_17).
+
+alert(inc43, endpoint, endpoint77).
+alert(inc43, suspicious_login, user_bob).
+alert(inc43, outbound_ip, ip_198_51_100_42).
+
+vulnerability(endpoint23, cve_critical_rce).
+threat_intel(ip_203_0_113_17, command_and_control).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+critical_asset(Endpoint) :-
+  asset(Endpoint, criticality, high).
+
+credential_abuse(Incident) :-
+  alert(Incident, suspicious_login, User),
+  privileged_user(User).
+
+malware_on_critical_asset(Incident) :-
+  alert(Incident, endpoint, Endpoint),
+  alert(Incident, malware_hash, _Hash),
+  critical_asset(Endpoint).
+
+c2_contact(Incident) :-
+  alert(Incident, outbound_ip, Ip),
+  threat_intel(Ip, command_and_control).
+
+exploitable_endpoint(Incident) :-
+  alert(Incident, endpoint, Endpoint),
+  vulnerability(Endpoint, cve_critical_rce).
+
+confirmed_compromise(Incident) :-
+  credential_abuse(Incident),
+  malware_on_critical_asset(Incident),
+  c2_contact(Incident),
+  exploitable_endpoint(Incident).
+
+type(Incident, confirmed_compromise) :-
+  confirmed_compromise(Incident).
+
+status(Incident, escalate_to_incident_response) :-
+  confirmed_compromise(Incident).
+
+reason(Incident, "privileged credential abuse, malware on a critical endpoint, C2 contact, and exploitable RCE are correlated") :-
+  confirmed_compromise(Incident).

package/examples/service-impact.pl

@@ -0,0 +1,41 @@
+% Practical cyclic recursion: incident impact analysis for a service dependency graph.
+% The payment stack has a real-world feedback cycle: payment_service calls
+% fraud_service, fraud_service calls risk_rules, and risk_rules calls payment_service
+% for authorization data. A payment outage should still produce a finite impact set.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(impactedByFailureOf, 2).
+materialize(status, 2).
+materialize(businessFunctionAtRisk, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+depends_on(web_store, checkout_api).
+depends_on(mobile_app, checkout_api).
+depends_on(checkout_api, payment_service).
+depends_on(checkout_api, inventory_service).
+depends_on(payment_service, fraud_service).
+depends_on(fraud_service, risk_rules).
+depends_on(risk_rules, payment_service).
+depends_on(inventory_service, stock_db).
+depends_on(stock_db, inventory_service).
+
+business_function(place_order, web_store).
+business_function(mobile_checkout, mobile_app).
+business_function(collect_payment, payment_service).
+business_function(screen_fraud, fraud_service).
+business_function(show_stock, inventory_service).
+
+failed(payment_service).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+impacted(Service, Failed) :- depends_on(Service, Failed).
+impacted(Service, Failed) :- depends_on(Service, Dependency), impacted(Dependency, Failed).
+
+affected(Service) :- failed(Failed), impacted(Service, Failed).
+affected(Service) :- failed(Service).
+
+affected_function(Function) :- business_function(Function, Service), affected(Service).
+
+impactedByFailureOf(Service, Failed) :- failed(Failed), impacted(Service, Failed).
+status(Service, failed) :- failed(Service).
+businessFunctionAtRisk(Function, true) :- affected_function(Function).

package/examples/sieve.pl

@@ -0,0 +1,20 @@
+% Prime enumeration inspired by Eyelet input/sieve.pl.
+% The 1000-limit answer matches Eyelet output-swipl/sieve.pl.
+%
+% eyelang uses the built-in smallest_divisor_from/3 relation to keep the
+% example fast while preserving the same generated prime list.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(primes, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+want_primes(1000).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+prime_under(Limit, P) :-
+  between(2, Limit, P),
+  smallest_divisor_from(P, 2, P).
+
+primes(Limit, Ps) :-
+  want_primes(Limit),
+  findall(P, prime_under(Limit, P), Ps).

package/examples/skolem-functions.pl

@@ -0,0 +1,52 @@
+% Skolem functional terms in rule heads.
+%
+% A generated resource should be deterministic and collision-free. Use a
+% function symbol whose arguments contain the values that make the resource
+% unique, such as skolem_observation(Patient, Test).
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(type, 2).
+materialize(patient, 2).
+materialize(test, 2).
+materialize(value, 2).
+materialize(about, 2).
+materialize(sameInputsSameId, 2).
+materialize(noObservationClash, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+test_result(alice, glucose, 6.8).
+test_result(alice, cholesterol, 4.2).
+test_result(bob, glucose, 5.1).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+high_glucose(Patient) :-
+  test_result(Patient, glucose, Value),
+  gt(Value, 6.0).
+
+observation_id(Patient, Test, skolem_observation(Patient, Test)) :-
+  test_result(Patient, Test, _Value).
+
+type(skolem_observation(Patient, Test), observation) :-
+  test_result(Patient, Test, _Value).
+
+patient(skolem_observation(Patient, Test), Patient) :-
+  test_result(Patient, Test, _Value).
+
+test(skolem_observation(Patient, Test), Test) :-
+  test_result(Patient, Test, _Value).
+
+value(skolem_observation(Patient, Test), Value) :-
+  test_result(Patient, Test, Value).
+
+type(skolem_alert(Patient, glucose), highGlucoseAlert) :-
+  high_glucose(Patient).
+
+about(skolem_alert(Patient, glucose), skolem_observation(Patient, glucose)) :-
+  high_glucose(Patient).
+
+sameInputsSameId(skolemDemo, true) :-
+  eq(skolem_observation(alice, glucose), skolem_observation(alice, glucose)).
+
+noObservationClash(skolemDemo, true) :-
+  neq(skolem_observation(alice, glucose), skolem_observation(alice, cholesterol)),
+  neq(skolem_observation(alice, glucose), skolem_observation(bob, glucose)).