# Human Idea Inbox ## 2026-03-10 - Metric Stack Clarification For this repo: - `val_bpb` is the trunk metric, not the whole-system king metric. - do not confuse the compression gauge with the steering wheel Use a layered view: - base LM: optimize held-out `val_bpb` - runtime/controller changes: also track `total_seconds`, `num_steps`, and `peak_vram_mb` - future selector/agent layers: target downstream utility under budget and constraints, not just language-model compression ## 2026-03-10 - Gemini "Opposite Math" Direction Try the anti-salience direction explicitly. Core framing: - salience math = discrete constrained selection with decomposed, legible utility - opposite math = unconstrained continuous synthesis under entangled black-box loss For this repo, the practical translation is: - remove or ablate explicit decomposed salience-style mechanisms - favor simpler continuous end-to-end optimization over hand-crafted modular scoring terms - test whether a plainer transformer beats the value-residual / gated additive structure Candidate experiments: - ablate value embeddings and their gate entirely - ablate extra residual scalar machinery if needed - keep the improved 5060 runtime path, then compare against the best branch on val_bpb ## 2026-03-10 - Bipolar Contextual Set Utility Do not just mix `U` and `-U`; that collapses to a rescaled scalar. Use separate channels: - `P(A, x)`: promotive value - `Q(A, x)`: aversive value - `Ξ(A, x)`: conflict / tension, e.g. `P * Q` For this repo, the practical translation is: - keep promotive and aversive signals separate inside the controller - only collapse them at the decision boundary - use conflict to trigger caution, not to erase structure Concrete low-risk experiment: - promotive signal = recent loss improvement - aversive signal = recent loss volatility / instability - conflict = promotive * aversive - use these to modulate LR gently on top of the current best 5060 schedule ## 2026-03-10 - Salience as Contextual Budgeted Set Selection Under Uncertain Utility The note below supersedes the earlier rough salience draft. I pushed it into a paper-ready shape and tightened the places where rigor usually goes feral. Matters * The objective is now cleanly split into latent downstream value `V*` and operational surrogate utility `Û`. * Hard exclusions are modeled as feasibility, not as tradeable penalties. * The propositions now make precise when itemwise ranking is exact, when redundancy gives diminishing returns, and when complementarity wrecks those guarantees. * I included a legacy mapping appendix, but it is role-based rather than symbol-for-symbol because the exact old `S′`, `UEA`, and `SRC` formulas are not in the visible thread. ## Salience as Contextual Budgeted Set Selection Under Uncertain Utility ### Abstract Many practical systems must choose a finite-cost subset of candidates when value depends on context, constraints, and interactions among the selected items. This paper formulates that problem as contextual budgeted set selection under uncertain utility. The true objective is latent expected downstream value, while the operational system optimizes a surrogate set utility that combines itemwise terms for novelty, goal-fit, long-run leverage, coherence, and temporal relevance with penalties for drag and redundancy and bonuses for complementarity. Hard safety, policy, validity, and compatibility constraints are represented as feasibility conditions rather than offsetting penalties. This yields a marginal-gain view of selection and clarifies the distinct roles of candidate generation, reranking, constrained optimization, control, and learning. Simpler salience-style formulas appear as restricted special cases. Stronger optimality claims require additional structure, such as modularity or submodularity, and should not be stated without those assumptions. --- ## 1. Introduction Finite-capacity selection recurs across retrieval, recommendation, memory management, routing, and attention support. A system faces more candidates than it can carry forward, each candidate consumes some resource, and the payoff of selecting a set depends both on context and on what else is selected. Many salience-style formulations compress this into a single scalar item score. That compression is often useful as a mnemonic, but it is too coarse as a general theory. The cleaner view is to treat salience as a constrained set-selection problem. A chooser operates under finite capacity, hard feasibility constraints, uncertain downstream utility, and interaction effects among selected items. In that setting, the right formal object is not a universal item score, but a contextual set objective together with a feasible family and a selection procedure. This reformulation makes four clarifications. First, it separates latent downstream value from the surrogate utility the system actually estimates and optimizes. Second, it places hard constraints in feasibility rather than in soft penalties. Third, it treats redundancy and complementarity as set properties rather than pretending they are intrinsic to isolated items. Fourth, it separates scoring from optimization, control, and learning. Those separations are structural, not cosmetic. --- ## 2. Formal Setup ### 2.1 Context, candidates, and feasibility Let `x` denote the exogenous context for a single decision episode. Context may include user state, task, session history, device, time horizon, risk posture, and any other state that changes what is valuable now. Unless stated otherwise, `x` is held fixed while the current selection problem is solved. If selection itself changes the relevant state, the model should be applied stagewise or lifted to a sequential decision framework. Let `I(x)` be the candidate universe available in context `x`. Each candidate `i ∈ I(x)` has: * hard item-level eligibility `T_i(x) ∈ {0,1}` * cost `c_i(x) > 0` when cost-normalized scoring is used Let `B(x)` denote the available budget or capacity. Some hard constraints are set-level rather than item-level. Let ```text C(A, x) ∈ {0,1} ``` denote any additional hard feasibility condition on a set `A`, such as mutual exclusion, compatibility, quota, schema, or channel constraints. Define the eligible universe ```text I⁺(x) = { i ∈ I(x) : T_i(x) = 1 } ``` and the feasible family ```text F(x) = { A ⊆ I⁺(x) : Σ_{i∈A} c_i(x) ≤ B(x), C(A, x) = 1 }. ``` This formulation keeps item-level gating and set-level gating distinct while allowing both to be enforced before or during selection. ### 2.2 Latent downstream value Let ```text V*(A, x) = E[Y(A, x) | x] ``` denote the latent expected downstream value of selecting `A` in context `x`, where the expectation is over whatever uncertainty remains after conditioning on context. The ideal chooser solves ```text A*(x) ∈ argmax_{A ∈ F(x)} V*(A, x). ``` In practice `V*` is not directly known. The system therefore estimates and optimizes a surrogate objective. ### 2.3 Remarks on zero-cost and sequential cases If genuinely zero-cost items exist, ratio scoring by `1 / c_i(x)` is not automatically meaningful. Those items should either be handled by raw marginal gain, by a separate convention, or by a richer cost model. If adding an item changes the context materially, write states `x_0, x_1, ...` and solve a sequence of stagewise selection problems or a fuller sequential decision problem. The present formulation addresses a single decision episode with context treated as fixed during selection. --- ## 3. Feature Vocabulary and Surrogate Utility ### 3.1 Stable feature vocabulary For each candidate `i`, define: * `N_i(x)`: novelty or information gain * `G_i(x)`: goal-fit or immediate relevance to the current task * `L_i(x)`: long-run leverage, such as reuse value, retention value, compounding value, or future usefulness * `H_i(x)`: coherence with the current trajectory, working set, or dialogue state * `τ_i(x)`: age, staleness, or lag * `D_i(x)`: drag, meaning friction, interruption cost, cognitive burden, latency burden, or soft risk burden For pairs of candidates `i, j`, define: * `K_ij(x)`: complementarity, synergy, or unlock value * `Sim_ij(x)`: redundancy, overlap, or substitutability Pairwise terms are taken to be symmetric unless otherwise stated. They are an approximation chosen for tractability, not a claim that all real interaction effects are pairwise. ### 3.2 Base item utility Let `θ` collect the parameters of the surrogate model. Define the base item utility ```text u_i(x; θ) = w_N(x) φ_N(N_i(x); x) + w_G(x) G_i(x) + w_L(x) L_i(x) + w_H(x) H_i(x) + w_F(x) φ_F(τ_i(x); x). ``` Here: * `w_*(x)` are contextual weights * `φ_N` is a learned or chosen novelty response * `φ_F` maps age or lag to temporal relevance This is the value of candidate `i` before interactions and soft burdens are applied. The weights should depend on context. Research mode, emergency mode, cold start, and long-session expert use should not all share the same tradeoff profile. ### 3.3 Set utility Define the surrogate set utility ```text Û(A, x; θ) = Σ_{i∈A} u_i(x; θ) + Σ_{i 160, ``` density-first ranking is not optimal in general for 0-1 knapsack. The goblin here is discreteness: fractional-knapsack intuition does not carry over. ### Proposition 3. Redundancy-only pairwise penalties yield a submodular surrogate Suppose `K_ij(x; θ) = 0` for all pairs and `Sim_ij(x; θ) ≥ 0`. Define ```text b_i(x; θ) = u_i(x; θ) - D_i(x; θ) ``` and consider ```text f(A) = Σ_{i∈A} b_i(x; θ) - λ_div(x) Σ_{i 0`. Then the pairwise complementarity term is supermodular, and the full surrogate may fail to be submodular. **Proof sketch.** Consider a simplified objective with one positive pair bonus: ```text f(A) = Σ_{i∈A} b_i + K_ab · 1[{a, b} ⊆ A]. ``` Take `A = ∅`, `B = {b}`, and add item `a`. Then ```text f({a}) - f(∅) = b_a ``` while ```text f({a, b}) - f({b}) = b_a + K_ab. ``` Since `K_ab > 0`, ```text b_a + K_ab > b_a. ``` So the marginal gain of adding `a` increases after `b` has already been selected. That violates diminishing returns. Hence positive complementarity can break submodularity. ### Proposition 5. Finite soft penalties cannot uniformly encode hard exclusion Suppose ineligibility is represented by subtracting a finite penalty `M > 0` instead of using a hard gate. That is, suppose the system uses ```text Ũ(A, x) = U(A, x) - M Σ_{i∈A} (1 - T_i(x)). ``` Then for any fixed `M`, there exist instances in which an ineligible item is still selected. **Proof sketch.** Pick an ineligible item `q` with `T_q(x) = 0` and assume it fits within the budget. If its base contribution to utility exceeds the finite penalty, meaning ```text Δ_q(∅, x) > M, ``` then its penalized marginal gain remains positive: ```text Δ_q(∅, x) - M > 0. ``` So the ineligible item can still be selected if it is valuable enough. Therefore no fixed finite penalty uniformly enforces hard exclusion across instances. Hard exclusion must live in feasibility, not in a tradeable soft term. --- ## 6. Algorithmic Implications The propositions above pin down what can and cannot be claimed. In the modular, equal-cost, cardinality-constrained regime, top-`k` ranking is exact. That is the cleanest setting in which a single itemwise score really does solve the problem. With modular utility and nonuniform costs, the problem becomes 0-1 knapsack. Even then, a density rule is only a heuristic, not a general optimum rule. With redundancy-only pairwise penalties and nonnegative similarities, the surrogate becomes submodular. In that regime, diminishing returns appears naturally, and submodular-style algorithms become mathematically natural. Once positive complementarity enters, the objective can become neither modular nor submodular. Then greedy procedures lose any blanket claim to optimality, and richer search or optimization procedures become appropriate. Depending on scale and latency budget, those may include beam search, local search, reranking loops, mixed-integer optimization, or learned approximate selectors. The safe statement is therefore narrow: > Algorithmic guarantees depend on the structure of the surrogate objective and the feasible family. They do not follow from a salience score alone. --- ## 7. Architectural Decomposition A practical system should separate six layers. ### 7.1 Eligibility layer Apply hard feasibility checks. Item-level disqualifiers go into `T_i(x)`. Set-level disqualifiers go into `C(A, x)`. Examples include safety rules, policy rules, schema validity, source validity thresholds, compatibility checks, mutual exclusion, and quota rules. ### 7.2 Candidate generation Recall a broad, cheap pool from the candidate universe. This stage optimizes coverage and speed, not final precision. ### 7.3 Reranker Estimate surrogate utility terms and interactions. This stage computes itemwise value signals, drag estimates, redundancy estimates, and complementarity estimates. ### 7.4 Selector Choose the final feasible set under `F(x)`. This stage is where greedy construction, beam search, local search, ILP, or other constrained optimization methods belong. ### 7.5 Controller Adjust exploration, aggressiveness, budget tightening, temperature, channel multipliers, or other policy knobs that govern behavior across contexts. Exploration belongs here, not inside a single salience score. ### 7.6 Learner Update `θ`, thresholds, transforms, interaction estimates, and controller policies from observed outcomes. Learning belongs here, not inside the same scalar equation used for online ranking. This decomposition is useful because it prevents hard constraints, soft utility, exploration, optimization, and learning from being crammed into one overworked formula. --- ## 8. Learning and Evaluation The separation between `V*` and `Û` has direct learning consequences. Observed feedback typically arrives only for the selected set, not for all counterfactual feasible sets. That means learning the surrogate is partly a counterfactual estimation problem. A system may estimate component models for itemwise terms and pairwise terms, fit a direct predictor of set-level outcomes, or combine both approaches. A generic learning target is to estimate parameters `θ` so that higher surrogate utility corresponds to better observed outcomes under deployment-relevant conditions. In symbolic form, one may fit `θ` by minimizing a loss of the form ```text Σ_t ℓ( ψ(A_t, x_t; θ), y_t ) + Ω(θ), ``` where `A_t` is the selected set in episode `t`, `y_t` is the observed outcome, `ψ` is the model output used for training, and `Ω` is any regularizer or structural penalty. Two evaluation cautions follow. First, when interactions matter, itemwise ranking metrics can become a misleading proxy for decision quality. A system that ranks individual items well can still assemble poor sets. Second, evaluation should track the level at which the system acts. If the selector chooses sets, then at least part of the evaluation should be set-level or policy-level rather than purely item-level. This is one more reason the latent-versus-surrogate split is not just notation cleanup. It affects the learning target and the evaluation protocol. --- ## 9. Domain Instantiations ### 9.1 Retrieval and RAG In retrieval settings: * `G` captures query relevance * `L` captures downstream usefulness for reasoning or future reuse * `H` captures coherence with the current dialogue or working set * `τ` captures source age or lag * `Sim` captures chunk overlap * `K` captures multi-hop complementarity across evidence pieces * `D` captures token cost, latency, or distraction burden * `T` and `C` capture trust, source validity, safety, and policy constraints ### 9.2 Training data selection In training data selection: * `N` captures undercoverage or surprise * `G` captures fit to the current training objective * `L` captures long-run capability gain * `H` captures curriculum coherence * `τ` captures distribution lag where relevant * `Sim` captures duplication or oversampling overlap * `K` captures complementary samples that unlock generalization * `D` captures labeling cost, noise burden, or instability risk * `T` and `C` capture license, validity, and policy constraints ### 9.3 Product and engagement systems In product flows: * `G` captures immediate task completion value * `L` captures retention or future utility * `H` captures journey coherence * `τ` captures timeliness * `Sim` captures recommendation redundancy * `K` captures next-step unlocks or useful bundles * `D` captures friction and interruption burden * `T` and `C` capture trust, safety, and experience constraints ### 9.4 Human operator mode For human reasoning, a compact salience heuristic can still be useful. But it should be treated as an operator shorthand over this substrate, not as the substrate itself. --- ## 10. Scope of Claims The model supports strong structural claims and weaker universal claims. Keeping those separate prevents puffed-up nonsense. Safe claims: * Many practical selection systems can be modeled as contextual feasible-set selection under uncertain utility. * Itemwise salience formulas are restricted special cases of that broader problem. * Hard exclusions are more robustly modeled as feasibility conditions than as finite penalties. * Redundancy can produce diminishing returns, while complementarity can destroy them. Unsafe claims unless extra assumptions are stated: * One scalar item score explains all selection behavior. * Greedy selection is optimal in general. * Value-per-cost ranking solves the nonuniform-cost case. * Hard constraints can always be replaced by sufficiently large soft penalties. --- ## 11. Conclusion The useful general principle is not that one salience equation explains everything. The useful principle is that finite-capacity selection is a contextual feasible-set problem under uncertain utility. Candidates have costs. Some candidates are ineligible. Value depends on context. Redundancy and complementarity are properties of sets, not just of isolated items. The deployed chooser acts on an estimated surrogate through feasible marginal gains, often normalized by cost when that normalization is meaningful. That framing preserves what was good in the original salience idea while removing notation drift, layer confusion, and fake universality. --- ## Appendix A. Compact Canonical Form The full problem can be summarized as follows. Given context `x`, define a feasible family ```text F(x) = { A ⊆ I⁺(x) : Σ_{i∈A} c_i(x) ≤ B(x), C(A, x) = 1 }. ``` Let latent downstream value be ```text V*(A, x) = E[Y(A, x) | x]. ``` Let surrogate utility be ```text Û(A, x; θ) = Σ_{i∈A} u_i(x; θ) + Σ_{i