eyeling 1.33.7 → 1.33.8

package/README.md

@@ -829,7 +829,7 @@ The eyelang engine has its own built-in registry under `lib/eyelang/builtins/`.
 | Aggregation | `findall/3`, `countall/2`, `sumall/3`, `aggregate_min/5`, `aggregate_max/5` |
 | Control | `not/1`, `once/1` |
 | Context terms | `holds/2`, `holds/3` |
-| Search and optimization helpers | `n_queens/2`, `weighted_hamiltonian_cycle/4`, `weighted_hamiltonian_path/4`, `hamiltonian_cycle/3`, `fixed_length_cycle/4`, `bounded_path/5`, `bounded_subset/7`, `cnf_model/3`, `qm_prime_implicants/4`, `qm_minimal_cover/4`, `alphametic_sum/5` |
+| Search and optimization helpers | `n_queens/2`, `weighted_hamiltonian_cycle/4`, `weighted_hamiltonian_path/4`, `hamiltonian_cycle/3`, `fixed_length_cycle/4`, `bounded_path/5`, `cnf_model/3`, `qm_prime_implicants/4`, `qm_minimal_cover/4`, `alphametic_sum/5` |
 | Numeric extension helpers | `extended_gcd/5`, `collatz_trajectory/2`, `kaprekar_steps/2`, `goldbach_pair/3` |
 | Matrix helpers | `matrix_sum/2`, `matrix_multiply/2`, `cholesky_decomposition/2`, `determinant/2`, `matrix_inv_triang/2`, `matrix_inversion/2` |
 

package/docs/eyelang-guide.md

@@ -415,12 +415,10 @@ The repository includes examples for recursion, graph reachability, finite searc
 | [`peasant.pl`](../examples/eyelang/peasant.pl) | Performs peasant multiplication and exponentiation. | [`output/peasant.pl`](../examples/eyelang/output/peasant.pl) |
 | [`pendulum-period.pl`](../examples/eyelang/pendulum-period.pl) | Computes simple pendulum periods. | [`output/pendulum-period.pl`](../examples/eyelang/output/pendulum-period.pl) |
 | [`polynomial.pl`](../examples/eyelang/polynomial.pl) | Finds complex integer polynomial roots. | [`output/polynomial.pl`](../examples/eyelang/output/polynomial.pl) |
-| [`project-portfolio-optimization.pl`](../examples/eyelang/project-portfolio-optimization.pl) | Optimizes a constrained project portfolio with pruning and aggregate builtins. | [`output/project-portfolio-optimization.pl`](../examples/eyelang/output/project-portfolio-optimization.pl) |
 | [`proof-contrapositive.pl`](../examples/eyelang/proof-contrapositive.pl) | Models proof by contrapositive. | [`output/proof-contrapositive.pl`](../examples/eyelang/output/proof-contrapositive.pl) |
 | [`quadratic-formula.pl`](../examples/eyelang/quadratic-formula.pl) | Solves sample quadratic equations. | [`output/quadratic-formula.pl`](../examples/eyelang/output/quadratic-formula.pl) |
 | [`quine-mccluskey.pl`](../examples/eyelang/quine-mccluskey.pl) | Minimizes Boolean terms with Quine-McCluskey. | [`output/quine-mccluskey.pl`](../examples/eyelang/output/quine-mccluskey.pl) |
 | [`radioactive-decay.pl`](../examples/eyelang/radioactive-decay.pl) | Computes radioactive decay over time. | [`output/radioactive-decay.pl`](../examples/eyelang/output/radioactive-decay.pl) |
-| [`resilient-city-orchestration.pl`](../examples/eyelang/resilient-city-orchestration.pl) | Orchestrates storm-response missions from signals, policy, routes, teams, and portfolio optimization. | [`output/resilient-city-orchestration.pl`](../examples/eyelang/output/resilient-city-orchestration.pl) |
 | [`riemann-hypothesis.pl`](../examples/eyelang/riemann-hypothesis.pl) | Checks a finite catalogue of non-trivial zeta zeros against the Riemann-hypothesis condition. | [`output/riemann-hypothesis.pl`](../examples/eyelang/output/riemann-hypothesis.pl) |
 | [`sat-dpll.pl`](../examples/eyelang/sat-dpll.pl) | Solves a finite SAT instance. | [`output/sat-dpll.pl`](../examples/eyelang/output/sat-dpll.pl) |
 | [`security-incident-correlation.pl`](../examples/eyelang/security-incident-correlation.pl) | Correlates security incidents across signals. | [`output/security-incident-correlation.pl`](../examples/eyelang/output/security-incident-correlation.pl) |

package/docs/eyelang-language-reference.md

@@ -468,7 +468,7 @@ An extension built-in SHOULD obey the same surface-language discipline as standa
 - it SHOULD document its intended modes, especially which arguments must be ground before it runs deterministically;
 - it MUST NOT change the meaning of ordinary facts, rules, unification, or standard built-ins.
 
-For example, an implementation may include extension modules for portfolio selection, number-theory algorithms, graph search, matrix operations, or alphametic puzzles. Those modules may be valuable and may make example programs much faster, but their predicate names, arities, algorithms, and modes are implementation-defined unless they are separately standardized.
+For example, an implementation may include extension modules for number-theory algorithms, graph search, matrix operations, or alphametic puzzles. Those modules may be valuable and may make example programs much faster, but their predicate names, arities, algorithms, and modes are implementation-defined unless they are separately standardized.
 
 An implementation that provides explanation output SHOULD make extension built-ins explainable at least as opaque successful or failed built-in calls, so that proof traces do not incorrectly report "no clauses" for a host-provided relation.
 

package/lib/eyelang/builtins/registry.js

@@ -7,7 +7,6 @@ import { listBuiltins } from './lists.js';
 import { aggregationBuiltins } from './aggregation.js';
 import { contextBuiltins } from './context.js';
 import { controlBuiltins } from './control.js';
-import { portfolioBuiltins } from './portfolio.js';
 import { searchBuiltins } from './search.js';
 import { numberTheoryBuiltins } from './number-theory.js';
 import { matrixBuiltins } from './matrix.js';
@@ -38,7 +37,7 @@ export class BuiltinRegistry {
 
 export function createDefaultRegistry() {
   const registry = new BuiltinRegistry();
-  for (const mod of [coreBuiltins, arithmeticBuiltins, stringBuiltins, listBuiltins, aggregationBuiltins, contextBuiltins, controlBuiltins, portfolioBuiltins, searchBuiltins, numberTheoryBuiltins, matrixBuiltins, alphameticBuiltins]) {
+  for (const mod of [coreBuiltins, arithmeticBuiltins, stringBuiltins, listBuiltins, aggregationBuiltins, contextBuiltins, controlBuiltins, searchBuiltins, numberTheoryBuiltins, matrixBuiltins, alphameticBuiltins]) {
     mod.register(registry);
   }
   return registry;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eyeling",
-  "version": "1.33.7",
+  "version": "1.33.8",
   "description": "A minimal Notation3 (N3) reasoner in JavaScript.",
   "main": "./index.js",
   "keywords": [

package/examples/eyelang/output/project-portfolio-optimization.pl

@@ -1,6 +0,0 @@
-bestPortfolio(portfolio2026, result(137, 75, 28, [solar, hvac, training, quality, recycling, cloud, security])).
-lowRiskTarget(portfolio2026, result(126, 74, 23, [solar, battery, hvac, training, quality, cloud])).
-feasibleCount(portfolio2026, 1390).
-projectCount(portfolio2026, 12).
-totalAvailableValue(portfolio2026, 268).
-note(portfolio2026, "aggregate builtins combine with pruning and memoization to avoid sorted candidate bags").

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

@@ -1,67 +0,0 @@
-incidentSummary(civic_storm, summary("CivicStorm Alpha", "protect people, medicine, and power without using prohibited surveillance", budget(105), riskCap(60))).
-activeSignal(civic_storm, river_surge).
-activeSignal(civic_storm, hospital_power_risk).
-activeSignal(civic_storm, medicine_cold_chain_risk).
-activeSignal(civic_storm, grid_stress).
-criticalNeed(civic_storm, evacuate_hospital).
-criticalNeed(civic_storm, deliver_medicine).
-criticalNeed(civic_storm, stabilize_substation).
-criticalNeed(civic_storm, open_shelter).
-criticalNeed(civic_storm, map_flood_front).
-policyClearance(medical_transport, deploy).
-policyClearance(cold_chain, deploy).
-policyClearance(grid_repair, deploy).
-policyClearance(shelter_ops, deploy).
-policyClearance(drone_mapping, deploy).
-policyClearance(public_info, deploy).
-usableRoute(hospital_quay, route([base, north_gate, hospital_quay], minutes(22), risk(9))).
-usableRoute(clinic_east, route([base, cold_depot, clinic_east], minutes(19), risk(5))).
-usableRoute(substation_east, route([base, north_gate, substation_east], minutes(31), risk(10))).
-usableRoute(high_school, route([base, civic_center, high_school], minutes(17), risk(4))).
-usableRoute(riverside, route([base, civic_center, riverside], minutes(21), risk(6))).
-usableRoute(civic_square, route([base, civic_center, civic_square], minutes(15), risk(3))).
-eligibleAssignment(evacuate_hospital, assignment(alpha_ambulance, [base, north_gate, hospital_quay])).
-eligibleAssignment(deliver_insulin, assignment(beta_coldchain, [base, cold_depot, clinic_east])).
-eligibleAssignment(stabilize_substation, assignment(delta_grid, [base, north_gate, substation_east])).
-eligibleAssignment(open_school_shelter, assignment(gamma_shelter, [base, civic_center, high_school])).
-eligibleAssignment(map_flood_front, assignment(echo_drone, [base, civic_center, riverside])).
-eligibleAssignment(public_dashboard, assignment(foxtrot_comms, [base, civic_center, civic_square])).
-candidateMission(evacuate_hospital, score(95, 34, 14, alpha_ambulance, [base, north_gate, hospital_quay])).
-candidateMission(deliver_insulin, score(70, 16, 9, beta_coldchain, [base, cold_depot, clinic_east])).
-candidateMission(stabilize_substation, score(85, 25, 18, delta_grid, [base, north_gate, substation_east])).
-candidateMission(open_school_shelter, score(60, 14, 6, gamma_shelter, [base, civic_center, high_school])).
-candidateMission(map_flood_front, score(45, 8, 8, echo_drone, [base, civic_center, riverside])).
-candidateMission(public_dashboard, score(28, 12, 4, foxtrot_comms, [base, civic_center, civic_square])).
-blockedMission(face_scan_crowds, policy_prohibition).
-blockedMission(resupply_west_bank, route_risk_too_high).
-bestResponse(civic_storm, response(value(355), cost(97), risk(55), missions([evacuate_hospital, deliver_insulin, stabilize_substation, open_school_shelter, map_flood_front]))).
-selectedMission(civic_storm, evacuate_hospital).
-selectedMission(civic_storm, deliver_insulin).
-selectedMission(civic_storm, stabilize_substation).
-selectedMission(civic_storm, open_school_shelter).
-selectedMission(civic_storm, map_flood_front).
-selectedTeam(evacuate_hospital, alpha_ambulance).
-selectedTeam(deliver_insulin, beta_coldchain).
-selectedTeam(stabilize_substation, delta_grid).
-selectedTeam(open_school_shelter, gamma_shelter).
-selectedTeam(map_flood_front, echo_drone).
-selectedRoute(evacuate_hospital, [base, north_gate, hospital_quay]).
-selectedRoute(deliver_insulin, [base, cold_depot, clinic_east]).
-selectedRoute(stabilize_substation, [base, north_gate, substation_east]).
-selectedRoute(open_school_shelter, [base, civic_center, high_school]).
-selectedRoute(map_flood_front, [base, civic_center, riverside]).
-coveredNeed(civic_storm, evacuate_hospital).
-coveredNeed(civic_storm, deliver_medicine).
-coveredNeed(civic_storm, stabilize_substation).
-coveredNeed(civic_storm, open_shelter).
-coveredNeed(civic_storm, map_flood_front).
-unmetNeed(civic_storm, none).
-readinessCheck(civic_storm, all_critical_needs_covered).
-readinessCheck(civic_storm, budget_and_risk_caps_respected).
-readinessCheck(civic_storm, prohibited_surveillance_rejected).
-readinessCheck(civic_storm, dangerous_west_bank_route_rejected).
-auditTrail(civic_storm, "raw sensor thresholds derive operational needs before search").
-auditTrail(civic_storm, "policy formula data is projected into deployable skill clearances").
-auditTrail(civic_storm, "bounded route search and team capabilities create candidate missions").
-auditTrail(civic_storm, "bounded_subset and aggregate_max choose the highest-value safe portfolio").
-recommendation(civic_storm, "activate the selected mission portfolio; do not deploy face recognition; defer west-bank resupply until route risk drops").

package/examples/eyelang/project-portfolio-optimization.pl

@@ -1,101 +0,0 @@
-% Capital project portfolio optimization.
-%
-% This is a practical finite-search benchmark: enumerate project portfolios
-% under budget and risk caps, pruning infeasible branches as cost and risk
-% accumulate, then use aggregate builtins to select useful optima without
-% building and sorting a large bag of candidate portfolios.
-
-% Output declarations: materialize/2 selects the relations written to this example's golden output.
-materialize(bestPortfolio, 2).
-materialize(lowRiskTarget, 2).
-materialize(feasibleCount, 2).
-materialize(projectCount, 2).
-materialize(totalAvailableValue, 2).
-materialize(note, 2).
-
-% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
-budget(portfolio2026, 75).
-riskCap(portfolio2026, 28).
-targetValue(portfolio2026, 125).
-
-allProjectData([
-  p(solar, 22, 15, 4),
-  p(battery, 28, 20, 5),
-  p(hvac, 20, 13, 3),
-  p(analytics, 18, 8, 7),
-  p(training, 16, 6, 2),
-  p(robotics, 35, 30, 9),
-  p(iot, 24, 12, 8),
-  p(quality, 19, 9, 4),
-  p(resilience, 26, 18, 6),
-  p(recycling, 14, 5, 3),
-  p(cloud, 21, 11, 5),
-  p(security, 25, 16, 7)
-]).
-
-% Derivation rules: each rule below contributes one logical step toward the displayed results.
-project(Name, Value, Cost, Risk) :-
-  allProjectData(Projects),
-  member(p(Name, Value, Cost, Risk), Projects).
-
-% Cache this finite relation so bestPortfolio/2, lowRiskTarget/2, and
-% feasibleCount/2 do not re-enumerate the same search space independently.
-memoize(feasiblePortfolio, 4).
-
-choosePortfolio([], _BudgetLeft, _RiskLeft, [], 0, 0, 0).
-choosePortfolio([p(Name, ProjectValue, ProjectCost, ProjectRisk) | Rest], BudgetLeft, RiskLeft, [Name | Chosen], Value, Cost, Risk) :-
-  le(ProjectCost, BudgetLeft),
-  le(ProjectRisk, RiskLeft),
-  sub(BudgetLeft, ProjectCost, NextBudget),
-  sub(RiskLeft, ProjectRisk, NextRisk),
-  choosePortfolio(Rest, NextBudget, NextRisk, Chosen, RestValue, RestCost, RestRisk),
-  add(ProjectValue, RestValue, Value),
-  add(ProjectCost, RestCost, Cost),
-  add(ProjectRisk, RestRisk, Risk).
-choosePortfolio([_Project | Rest], BudgetLeft, RiskLeft, Chosen, Value, Cost, Risk) :-
-  choosePortfolio(Rest, BudgetLeft, RiskLeft, Chosen, Value, Cost, Risk).
-
-feasiblePortfolio(Selected, Value, Cost, Risk) :-
-  budget(portfolio2026, Budget),
-  riskCap(portfolio2026, Cap),
-  allProjectData(Projects),
-  bounded_subset(Projects, Budget, Cap, Selected, Value, Cost, Risk),
-  gt(Value, 0).
-
-scoredPortfolio(Selected, Value, Cost, Risk, NegCost, NegRisk) :-
-  feasiblePortfolio(Selected, Value, Cost, Risk),
-  neg(Cost, NegCost),
-  neg(Risk, NegRisk).
-
-targetPortfolio(Target, Selected, Value, Cost, Risk) :-
-  feasiblePortfolio(Selected, Value, Cost, Risk),
-  ge(Value, Target).
-
-bestPortfolio(portfolio2026, result(Value, Cost, Risk, Selected)) :-
-  aggregate_max(
-    [Value, NegCost, NegRisk, Selected],
-    result(Value, Cost, Risk, Selected),
-    scoredPortfolio(Selected, Value, Cost, Risk, NegCost, NegRisk),
-    _Key,
-    result(Value, Cost, Risk, Selected)).
-
-lowRiskTarget(portfolio2026, result(Value, Cost, Risk, Selected)) :-
-  targetValue(portfolio2026, Target),
-  aggregate_min(
-    [Risk, Cost, Selected],
-    result(Value, Cost, Risk, Selected),
-    targetPortfolio(Target, Selected, Value, Cost, Risk),
-    _Key,
-    result(Value, Cost, Risk, Selected)).
-
-feasibleCount(portfolio2026, Count) :-
-  countall(feasiblePortfolio(_Selected, _Value, _Cost, _Risk), Count).
-
-projectCount(portfolio2026, Count) :-
-  countall(project(_Name, _Value, _Cost, _Risk), Count).
-
-totalAvailableValue(portfolio2026, Total) :-
-  sumall(Value, project(_Name, Value, _Cost, _Risk), Total).
-
-note(portfolio2026, "aggregate builtins combine with pruning and memoization to avoid sorted candidate bags") :-
-  eq(ok, ok).

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

@@ -1,303 +0,0 @@
-% 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
-% holds/2, 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, Context),
-  holds(Context, permission(Skill, deploy)),
-  not(policyBlocked(Skill, deploy)).
-
-policyBlocked(Skill, deploy) :-
-  policy_bundle(response_policy, Context),
-  holds(Context, prohibition(Skill, 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/lib/eyelang/builtins/portfolio.js

@@ -1,73 +0,0 @@
-// Reusable bounded-subset optimizer for finite knapsack-style examples.
-// Items are p(Name, Value, Cost, Risk) terms; the builtin enumerates every
-// subset whose total cost/risk stays within the supplied caps.
-import { deref, listFromItems, numberTerm, properListItems, unify } from '../term.js';
-
-export const portfolioBuiltins = {
-  register(registry) {
-    registry.add('bounded_subset', 7, boundedSubset, {
-      fallbackWhenNotReady: true,
-      ready: boundedSubsetReady,
-    });
-  }
-};
-
-function boundedSubsetReady(goal, env) {
-  return parseItems(goal.args[0], env) !== null && intArg(goal.args[1], env) !== null && intArg(goal.args[2], env) !== null;
-}
-
-function* boundedSubset({ goal, env }) {
-  const items = parseItems(goal.args[0], env);
-  const budget = intArg(goal.args[1], env);
-  const riskCap = intArg(goal.args[2], env);
-  if (!items || budget == null || riskCap == null) return;
-  for (const answer of enumerate(items, 0, budget, riskCap)) {
-    const next = env.clone();
-    if (unify(goal.args[3], listFromItems(answer.names), next) &&
-        unify(goal.args[4], numberTerm(answer.value), next) &&
-        unify(goal.args[5], numberTerm(answer.cost), next) &&
-        unify(goal.args[6], numberTerm(answer.risk), next)) {
-      yield next;
-    }
-  }
-}
-
-function* enumerate(items, index, budget, riskLeft) {
-  if (index >= items.length) {
-    yield { names: [], value: 0, cost: 0, risk: 0 };
-    return;
-  }
-  const item = items[index];
-  if (item.cost <= budget && item.risk <= riskLeft) {
-    for (const rest of enumerate(items, index + 1, budget - item.cost, riskLeft - item.risk)) {
-      yield {
-        names: [item.name, ...rest.names],
-        value: item.value + rest.value,
-        cost: item.cost + rest.cost,
-        risk: item.risk + rest.risk,
-      };
-    }
-  }
-  yield* enumerate(items, index + 1, budget, riskLeft);
-}
-
-function parseItems(term, env) {
-  const list = properListItems(term, env);
-  if (!list) return null;
-  const items = [];
-  for (const itemTerm of list) {
-    const item = deref(itemTerm, env);
-    if (item.type !== 'compound' || item.name !== 'p' || item.arity !== 4) return null;
-    const value = intArg(item.args[1], env), cost = intArg(item.args[2], env), risk = intArg(item.args[3], env);
-    if (value == null || cost == null || risk == null) return null;
-    items.push({ name: item.args[0], value, cost, risk });
-  }
-  return items;
-}
-
-function intArg(term, env) {
-  const value = deref(term, env);
-  if (value.type !== 'number' || !/^-?\d+$/.test(value.name)) return null;
-  const n = Number(value.name);
-  return Number.isSafeInteger(n) ? n : null;
-}

package/test/eyelang/conformance/cases/extension/046_bounded_subset.pl

@@ -1,4 +0,0 @@
-% Reference 9.5: bounded_subset/7 enumerates subsets within budget and risk caps.
-projects([p(a, 5, 3, 1), p(b, 4, 2, 2), p(c, 7, 5, 3)]).
-answer(selection, result(Names, Value, Cost, Risk)) :- projects(Ps), bounded_subset(Ps, 5, 3, Names, Value, Cost, Risk).
-materialize(answer, 2).

package/test/eyelang/conformance/expected/extension/046_bounded_subset.out

@@ -1,5 +0,0 @@
-answer(selection, result([a, b], 9, 5, 3)).
-answer(selection, result([a], 5, 3, 1)).
-answer(selection, result([b], 4, 2, 2)).
-answer(selection, result([c], 7, 5, 3)).
-answer(selection, result([], 0, 0, 0)).