eyeling 1.32.1 → 1.33.0

package/examples/eyelang/resilient-city-orchestration.pl

@@ -0,0 +1,303 @@
+% Resilient-city orchestration scenario.
+%
+% This example is intentionally richer than a single puzzle.  It combines raw
+% incident signals, policy-as-data, route search, team capabilities, negation,
+% aggregation, finite optimization, and materialized audit output.  The result is
+% a compact declarative emergency plan: facts describe the world; rules decide
+% which missions are lawful, reachable, and worth funding under cost/risk caps.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(incidentSummary, 2).
+materialize(activeSignal, 2).
+materialize(criticalNeed, 2).
+materialize(policyClearance, 2).
+materialize(usableRoute, 2).
+materialize(eligibleAssignment, 2).
+materialize(candidateMission, 2).
+materialize(blockedMission, 2).
+materialize(bestResponse, 2).
+materialize(selectedMission, 2).
+materialize(selectedTeam, 2).
+materialize(selectedRoute, 2).
+materialize(coveredNeed, 2).
+materialize(unmetNeed, 2).
+materialize(readinessCheck, 2).
+materialize(auditTrail, 2).
+materialize(recommendation, 2).
+
+% Program structure: facts set up the storm response, and rules derive the final plan.
+incident(civic_storm).
+incident_label(civic_storm, "CivicStorm Alpha").
+incident_goal(civic_storm, "protect people, medicine, and power without using prohibited surveillance").
+budget_cap(civic_storm, 105).
+risk_cap(civic_storm, 60).
+route_risk_cap(civic_storm, 20).
+route_minutes_cap(civic_storm, 45).
+
+% Sensor readings are deliberately low-level; rules below turn them into needs.
+reading(river_gauge_cm, 318).
+threshold(river_gauge_cm, 280).
+reading(hospital_generator_hours, 5).
+threshold_low(hospital_generator_hours, 8).
+reading(clinic_refrigerator_hours, 4).
+threshold_low(clinic_refrigerator_hours, 6).
+reading(substation_load_percent, 94).
+threshold(substation_load_percent, 85).
+
+% The deployable skills are stored as quoted formula data and projected by
+% formula_binary/4, showing how policy documents can be reasoned over as data.
+policy_bundle(response_policy, (
+  permission(medical_transport, deploy),
+  permission(cold_chain, deploy),
+  permission(grid_repair, deploy),
+  permission(shelter_ops, deploy),
+  permission(drone_mapping, deploy),
+  permission(public_info, deploy),
+  prohibition(public_face_recognition, deploy)
+)).
+
+% Teams can only serve missions whose skill they possess and whose route is usable.
+team(alpha_ambulance).
+teamSkill(alpha_ambulance, medical_transport).
+teamStatus(alpha_ambulance, ready).
+team(beta_coldchain).
+teamSkill(beta_coldchain, cold_chain).
+teamStatus(beta_coldchain, ready).
+team(delta_grid).
+teamSkill(delta_grid, grid_repair).
+teamStatus(delta_grid, ready).
+team(gamma_shelter).
+teamSkill(gamma_shelter, shelter_ops).
+teamStatus(gamma_shelter, ready).
+team(echo_drone).
+teamSkill(echo_drone, drone_mapping).
+teamStatus(echo_drone, ready).
+team(foxtrot_comms).
+teamSkill(foxtrot_comms, public_info).
+teamStatus(foxtrot_comms, ready).
+team(omega_vision).
+teamSkill(omega_vision, public_face_recognition).
+teamStatus(omega_vision, ready).
+
+% The road graph is directed.  bounded_path/5 discovers simple bounded routes.
+road(base, north_gate).
+road(north_gate, hospital_quay).
+road(base, cold_depot).
+road(cold_depot, clinic_east).
+road(north_gate, substation_east).
+road(base, civic_center).
+road(civic_center, high_school).
+road(civic_center, riverside).
+road(civic_center, civic_square).
+road(base, west_bridge).
+road(west_bridge, west_bank).
+
+zone(hospital_quay).
+zone(clinic_east).
+zone(substation_east).
+zone(high_school).
+zone(riverside).
+zone(civic_square).
+zone(west_bank).
+
+routeRisk(hospital_quay, 9).
+routeRisk(clinic_east, 5).
+routeRisk(substation_east, 10).
+routeRisk(high_school, 4).
+routeRisk(riverside, 6).
+routeRisk(civic_square, 3).
+routeRisk(west_bank, 24).
+routeMinutes(hospital_quay, 22).
+routeMinutes(clinic_east, 19).
+routeMinutes(substation_east, 31).
+routeMinutes(high_school, 17).
+routeMinutes(riverside, 21).
+routeMinutes(civic_square, 15).
+routeMinutes(west_bank, 42).
+
+% Mission facts carry the operational need, location, required skill, value,
+% budget cost, and base risk.  Route risk is added by candidateMission/2.
+missionBase(evacuate_hospital, evacuate_hospital, hospital_quay, medical_transport, 95, 34, 5).
+missionBase(deliver_insulin, deliver_medicine, clinic_east, cold_chain, 70, 16, 4).
+missionBase(stabilize_substation, stabilize_substation, substation_east, grid_repair, 85, 25, 8).
+missionBase(open_school_shelter, open_shelter, high_school, shelter_ops, 60, 14, 2).
+missionBase(map_flood_front, map_flood_front, riverside, drone_mapping, 45, 8, 2).
+missionBase(public_dashboard, public_information, civic_square, public_info, 28, 12, 1).
+missionBase(face_scan_crowds, situational_awareness, civic_square, public_face_recognition, 90, 20, 2).
+missionBase(resupply_west_bank, shelter_supply, west_bank, shelter_ops, 50, 20, 5).
+
+% Memoized derived predicates keep the example readable while avoiding repeated finite searches.
+memoize(usableRoute, 2).
+memoize(candidateMission, 2).
+memoize(bestResponse, 2).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+incidentSummary(Incident, summary(Label, Goal, budget(Budget), riskCap(RiskCap))) :-
+  incident_label(Incident, Label),
+  incident_goal(Incident, Goal),
+  budget_cap(Incident, Budget),
+  risk_cap(Incident, RiskCap).
+
+activeSignal(civic_storm, river_surge) :-
+  reading(river_gauge_cm, Value),
+  threshold(river_gauge_cm, Threshold),
+  ge(Value, Threshold).
+activeSignal(civic_storm, hospital_power_risk) :-
+  reading(hospital_generator_hours, Value),
+  threshold_low(hospital_generator_hours, Threshold),
+  le(Value, Threshold).
+activeSignal(civic_storm, medicine_cold_chain_risk) :-
+  reading(clinic_refrigerator_hours, Value),
+  threshold_low(clinic_refrigerator_hours, Threshold),
+  le(Value, Threshold).
+activeSignal(civic_storm, grid_stress) :-
+  reading(substation_load_percent, Value),
+  threshold(substation_load_percent, Threshold),
+  ge(Value, Threshold).
+
+criticalNeed(civic_storm, evacuate_hospital) :-
+  activeSignal(civic_storm, river_surge),
+  activeSignal(civic_storm, hospital_power_risk).
+criticalNeed(civic_storm, deliver_medicine) :-
+  activeSignal(civic_storm, medicine_cold_chain_risk).
+criticalNeed(civic_storm, stabilize_substation) :-
+  activeSignal(civic_storm, grid_stress).
+criticalNeed(civic_storm, open_shelter) :-
+  activeSignal(civic_storm, river_surge).
+criticalNeed(civic_storm, map_flood_front) :-
+  activeSignal(civic_storm, river_surge).
+
+policyClearance(Skill, deploy) :-
+  policy_bundle(response_policy, Formula),
+  formula_binary(Formula, Skill, permission, deploy),
+  not(policyBlocked(Skill, deploy)).
+
+policyBlocked(Skill, deploy) :-
+  policy_bundle(response_policy, Formula),
+  formula_binary(Formula, Skill, prohibition, deploy).
+
+usableRoute(Zone, route(Path, minutes(Minutes), risk(RouteRisk))) :-
+  zone(Zone),
+  bounded_path(road, base, Zone, 3, Path),
+  routeMinutes(Zone, Minutes),
+  routeRisk(Zone, RouteRisk),
+  route_minutes_cap(civic_storm, MinutesCap),
+  route_risk_cap(civic_storm, RiskCap),
+  le(Minutes, MinutesCap),
+  le(RouteRisk, RiskCap).
+
+eligibleAssignment(Mission, assignment(Team, Path)) :-
+  missionBase(Mission, _Need, Zone, Skill, _Value, _Cost, _BaseRisk),
+  policyClearance(Skill, deploy),
+  teamSkill(Team, Skill),
+  teamStatus(Team, ready),
+  usableRoute(Zone, route(Path, minutes(_Minutes), risk(_RouteRisk))).
+
+candidateMission(Mission, score(Value, Cost, TotalRisk, Team, Path)) :-
+  missionBase(Mission, _Need, Zone, Skill, Value, Cost, BaseRisk),
+  policyClearance(Skill, deploy),
+  teamSkill(Team, Skill),
+  teamStatus(Team, ready),
+  usableRoute(Zone, route(Path, minutes(_Minutes), risk(RouteRisk))),
+  add(BaseRisk, RouteRisk, TotalRisk).
+
+blockedMission(Mission, policy_prohibition) :-
+  missionBase(Mission, _Need, _Zone, Skill, _Value, _Cost, _BaseRisk),
+  policyBlocked(Skill, deploy).
+blockedMission(Mission, route_risk_too_high) :-
+  missionBase(Mission, _Need, Zone, _Skill, _Value, _Cost, _BaseRisk),
+  routeRisk(Zone, RouteRisk),
+  route_risk_cap(civic_storm, Cap),
+  gt(RouteRisk, Cap).
+blockedMission(Mission, no_eligible_assignment) :-
+  missionBase(Mission, _Need, _Zone, _Skill, _Value, _Cost, _BaseRisk),
+  not(candidateMission(Mission, _Score)),
+  not(blockedMission(Mission, policy_prohibition)),
+  not(blockedMission(Mission, route_risk_too_high)).
+
+missionItem(p(Mission, Value, Cost, Risk)) :-
+  candidateMission(Mission, score(Value, Cost, Risk, _Team, _Path)).
+
+missionItems(Items) :-
+  findall(Item, missionItem(Item), Items).
+
+missionAddressesNeed(Mission, Need) :-
+  missionBase(Mission, Need, _Zone, _Skill, _Value, _Cost, _BaseRisk).
+
+planCoversNeed(Plan, Need) :-
+  member(Mission, Plan),
+  missionAddressesNeed(Mission, Need).
+
+uncoveredNeedInPlan(Plan, Need) :-
+  criticalNeed(civic_storm, Need),
+  not(planCoversNeed(Plan, Need)).
+
+coversAllCriticalNeeds(Plan) :-
+  not(uncoveredNeedInPlan(Plan, _Need)).
+
+candidateResponse(Plan, Value, Cost, Risk, NegCost, NegRisk) :-
+  budget_cap(civic_storm, Budget),
+  risk_cap(civic_storm, RiskCap),
+  missionItems(Items),
+  bounded_subset(Items, Budget, RiskCap, Plan, Value, Cost, Risk),
+  coversAllCriticalNeeds(Plan),
+  neg(Cost, NegCost),
+  neg(Risk, NegRisk).
+
+bestResponse(civic_storm, response(value(Value), cost(Cost), risk(Risk), missions(Plan))) :-
+  aggregate_max(
+    [Value, NegCost, NegRisk, Plan],
+    response(value(Value), cost(Cost), risk(Risk), missions(Plan)),
+    candidateResponse(Plan, Value, Cost, Risk, NegCost, NegRisk),
+    _Key,
+    response(value(Value), cost(Cost), risk(Risk), missions(Plan))).
+
+selectedMission(civic_storm, Mission) :-
+  bestResponse(civic_storm, response(value(_Value), cost(_Cost), risk(_Risk), missions(Plan))),
+  member(Mission, Plan).
+
+selectedTeam(Mission, Team) :-
+  selectedMission(civic_storm, Mission),
+  candidateMission(Mission, score(_Value, _Cost, _Risk, Team, _Path)).
+
+selectedRoute(Mission, Path) :-
+  selectedMission(civic_storm, Mission),
+  candidateMission(Mission, score(_Value, _Cost, _Risk, _Team, Path)).
+
+coveredNeed(civic_storm, Need) :-
+  selectedMission(civic_storm, Mission),
+  missionAddressesNeed(Mission, Need).
+
+unmetNeed(civic_storm, Need) :-
+  bestResponse(civic_storm, response(value(_Value), cost(_Cost), risk(_Risk), missions(Plan))),
+  uncoveredNeedInPlan(Plan, Need).
+unmetNeed(civic_storm, none) :-
+  bestResponse(civic_storm, response(value(_Value), cost(_Cost), risk(_Risk), missions(Plan))),
+  coversAllCriticalNeeds(Plan).
+
+readinessCheck(civic_storm, all_critical_needs_covered) :-
+  unmetNeed(civic_storm, none).
+readinessCheck(civic_storm, budget_and_risk_caps_respected) :-
+  bestResponse(civic_storm, response(value(_Value), cost(Cost), risk(Risk), missions(_Plan))),
+  budget_cap(civic_storm, Budget),
+  risk_cap(civic_storm, Cap),
+  le(Cost, Budget),
+  le(Risk, Cap).
+readinessCheck(civic_storm, prohibited_surveillance_rejected) :-
+  blockedMission(face_scan_crowds, policy_prohibition).
+readinessCheck(civic_storm, dangerous_west_bank_route_rejected) :-
+  blockedMission(resupply_west_bank, route_risk_too_high).
+
+auditTrail(civic_storm, "raw sensor thresholds derive operational needs before search") :-
+  eq(ok, ok).
+auditTrail(civic_storm, "policy formula data is projected into deployable skill clearances") :-
+  eq(ok, ok).
+auditTrail(civic_storm, "bounded route search and team capabilities create candidate missions") :-
+  eq(ok, ok).
+auditTrail(civic_storm, "bounded_subset and aggregate_max choose the highest-value safe portfolio") :-
+  eq(ok, ok).
+
+recommendation(civic_storm, "activate the selected mission portfolio; do not deploy face recognition; defer west-bank resupply until route risk drops") :-
+  readinessCheck(civic_storm, all_critical_needs_covered),
+  readinessCheck(civic_storm, prohibited_surveillance_rejected),
+  readinessCheck(civic_storm, dangerous_west_bank_route_rejected).

package/examples/eyelang/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/eyelang/sat-dpll.pl

@@ -0,0 +1,80 @@
+% SAT solving without cut.
+%
+% A compact DPLL-style example for a finite CNF formula.  The program first
+% generates truth assignments, then checks every clause declaratively.  This
+% larger instance has eight variables and twelve clauses, so it is still small
+% enough for full model collection but no longer a toy four-variable search.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(status, 2).
+materialize(witness, 2).
+materialize(modelCount, 2).
+materialize(variableCount, 2).
+materialize(clauseCount, 2).
+materialize(reason, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+problem(sat_instance,
+  [a, b, c, d, e, f, g, h],
+  [
+    [pos(a), pos(b)],
+    [neg(a), pos(c)],
+    [neg(b), pos(d)],
+    [pos(c), pos(d)],
+    [neg(c), pos(e)],
+    [neg(d), pos(f)],
+    [pos(e), pos(f)],
+    [neg(e), pos(g)],
+    [neg(f), pos(h)],
+    [pos(g), pos(h)],
+    [neg(g), pos(a)],
+    [neg(h), pos(b)]
+  ]).
+
+truth(false).
+truth(true).
+
+assignment([], []).
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+assignment([Var|Vars], [value(Var, Truth)|Rest]) :-
+  truth(Truth),
+  assignment(Vars, Rest).
+
+literal_true(pos(Var), Assignment) :-
+  member(value(Var, true), Assignment).
+literal_true(neg(Var), Assignment) :-
+  member(value(Var, false), Assignment).
+
+clause_true([Literal|_Rest], Assignment) :-
+  literal_true(Literal, Assignment).
+clause_true([_Literal|Rest], Assignment) :-
+  clause_true(Rest, Assignment).
+
+cnf_true([], _Assignment).
+cnf_true([Clause|Clauses], Assignment) :-
+  clause_true(Clause, Assignment),
+  cnf_true(Clauses, Assignment).
+
+model(Name, Assignment) :-
+  problem(Name, Variables, Clauses),
+  cnf_model(Variables, Clauses, Assignment).
+
+status(sat_instance, satisfiable) :-
+  once(model(sat_instance, _Assignment)).
+
+witness(sat_instance, Assignment) :-
+  once(model(sat_instance, Assignment)).
+
+modelCount(sat_instance, Count) :-
+  findall(Assignment, model(sat_instance, Assignment), Models),
+  length(Models, Count).
+
+variableCount(sat_instance, Count) :-
+  problem(sat_instance, Variables, _Clauses),
+  length(Variables, Count).
+
+clauseCount(sat_instance, Count) :-
+  problem(sat_instance, _Variables, Clauses),
+  length(Clauses, Count).
+
+reason(sat_instance, "finite 8-variable CNF search succeeds without cut").

package/examples/eyelang/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/eyelang/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/eyelang/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/eyelang/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)).