perf(metrics): tighten ChangelessWaste bound for rate_diff < 0

The previous bound for `rate_diff < 0` was `all_selected.input_weight * rate_diff`,
which ignored that selecting every candidate would typically force a change
output (making the selection infeasible under the changeless constraint). The
new bound recasts the problem as: minimize the weight of candidates excluded
from `D_all` such that `excess_with_drain` drops below `change_policy.min_value`.
This is a 0/1 covering knapsack; the LP relaxation (sort positive-ev_feerate
candidates by `ev/weight` descending and exclude fractionally) gives a safe
upper bound on `D.input_weight` for any feasible changeless descendant.

Benchmark improvements (round counts, BnB cap 2M):
  n=15 rate_diff_neg:  3,590  ->    415   (~9x)
  n=20 rate_diff_neg: 34,296  ->  2,138   (~16x)
  n=30 rate_diff_neg: 2M cap  -> 74,055   (>27x, was hitting cap)

rate_diff >= 0 paths are unchanged. `ensure_bound_is_not_too_tight` proptest
verifies the new LB across 256 randomized scenarios.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: evanlinjin

src/metrics/changeless_waste.rs

@@ -1,5 +1,6 @@
 use super::change_lower_bound;
 use crate::{bnb::BnbMetric, float::Ordf32, ChangePolicy, CoinSelector, Drain, FeeRate, Target};
+use alloc::vec::Vec;
 
 /// Metric that minimizes the [waste metric] subject to the constraint that the selection produces
 /// no change output.
@@ -54,37 +55,34 @@ impl BnbMetric for ChangelessWaste {
         //     score(D) = D.input_weight * rate_diff + max(0, D.excess)
         //
         // and `D.excess >= 0` (target met), so `score(D) >= D.input_weight * rate_diff`. The
-        // bound therefore reduces to finding a lower bound on `D.input_weight * rate_diff`.
+        // bound therefore reduces to bounding `D.input_weight` in the right direction.
 
         if rate_diff < 0.0 {
-            // rate_diff < 0: the most negative `D.input_weight * rate_diff` comes from the
-            // largest possible input_weight, which is bounded by selecting every candidate.
-            // (`D` need not actually be feasible — we only need an LB on its score.)
-            let mut all = cs.clone();
-            all.select_all();
-            return Some(Ordf32(all.input_weight() as f32 * rate_diff));
+            // rate_diff < 0: we want an UPPER bound on `D.input_weight`. `all_selected` is a
+            // safe but loose UB; we tighten by LP-relaxed knapsack over candidates that
+            // *must* be excluded to keep the selection changeless.
+            let ub = ub_changeless_input_weight(cs, self.target, self.change_policy);
+            return Some(Ordf32(ub * rate_diff));
         }
 
-        // rate_diff >= 0: smaller input_weight gives a smaller `input_weight * rate_diff`, so we
-        // want a lower bound on `D.input_weight`. `D.input_weight >= cs.input_weight` always
-        // (selecting only grows), but we can do much better when the target is not yet met.
+        // rate_diff >= 0: we want a LOWER bound on `D.input_weight`. `cs.input_weight` is a
+        // safe baseline (input_weight is monotone non-decreasing). Tighten with the resize
+        // trick when target is not yet met.
         if cs.is_target_met(self.target) {
             return Some(Ordf32(cs.input_weight() as f32 * rate_diff));
         }
 
-        // Target not met. Use the same resize trick as `LowestFee::bound`: walk the sorted
-        // unselected list until we cross the target, then pretend the crossing input was
-        // perfectly scaled so that the target is hit with zero excess. Among all subsets of
-        // unselected that reach target, the highest-`value_pwu` candidates are the most
-        // weight-efficient — so the resize-scaled prefix is a valid lower bound on any
-        // target-meeting descendant's input_weight.
+        // Target not met. Same resize trick as `LowestFee::bound`: walk the sorted unselected
+        // list until we cross the target, then pretend the crossing input was perfectly
+        // scaled so the target is hit with zero excess. Among all subsets of unselected that
+        // reach target, the highest-`value_pwu` candidates are the most weight-efficient — so
+        // the resize-scaled prefix is a valid lower bound on any target-meeting descendant's
+        // input_weight.
         let (mut cs, resize_index, to_resize) = cs
             .clone()
             .select_iter()
             .find(|(cs, _, _)| cs.is_target_met(self.target))?;
 
-        // If the find selection already hits target exactly, that's the minimum-weight
-        // target-meeting subset; the bound is its waste (with `Drain::NONE`).
         if cs.excess(self.target, Drain::NONE) == 0 {
             return Some(Ordf32(cs.waste(
                 self.target,
@@ -95,7 +93,6 @@ impl BnbMetric for ChangelessWaste {
         }
         cs.deselect(resize_index);
 
-        // Compute the smallest `scale` of `to_resize` that satisfies each fee constraint.
         let mut scale = Ordf32(0.0);
 
         let rate_excess = cs.rate_excess_wu(self.target, Drain::NONE) as f32;
@@ -138,3 +135,77 @@ impl BnbMetric for ChangelessWaste {
         true
     }
 }
+
+/// LP-relaxed upper bound on `D.input_weight` for changeless `D ⊇ cs` (used by the
+/// `rate_diff < 0` branch of `ChangelessWaste::bound`).
+///
+/// Construct `D_all = cs ∪ all unselected`. If `D_all` itself is changeless, the UB is
+/// `D_all.input_weight`. Otherwise we must exclude enough excess-contributing
+/// (positive-`ev_feerate`) candidates to drop `excess(drain_weights)` below
+/// `change_policy.min_value`. To MAXIMIZE the remaining `input_weight` we MINIMIZE the
+/// excluded weight, sorting positive-`ev_feerate` candidates by `ev_feerate / weight`
+/// descending and removing fractionally until the required `delta` is met.
+///
+/// The LP relaxation gives a value `>=` any integer solution's excluded weight, so
+/// `D_all.input_weight - LP_min` is a safe UB for any feasible `D.input_weight`. The
+/// `input_weight()` segwit/varint corrections only ever ADD weight to the parent, never
+/// subtract from a subset — so the additive subtraction is safe in the UB direction.
+fn ub_changeless_input_weight(
+    cs: &CoinSelector<'_>,
+    target: Target,
+    change_policy: ChangePolicy,
+) -> f32 {
+    let mut d_all = cs.clone();
+    d_all.select_all();
+    let d_all_iw = d_all.input_weight() as f32;
+
+    let excess_with_drain = d_all.excess(
+        target,
+        Drain {
+            weights: change_policy.drain_weights,
+            value: 0,
+        },
+    );
+    let delta = excess_with_drain - change_policy.min_value as i64;
+    if delta <= 0 {
+        return d_all_iw;
+    }
+    let mut remaining = delta as f32;
+
+    let mut pos: Vec<(f32, f32)> = cs
+        .unselected()
+        .filter_map(|(_, c)| {
+            let ev = c.effective_value(target.fee.rate);
+            if ev > 0.0 {
+                Some((ev, c.weight as f32))
+            } else {
+                None
+            }
+        })
+        .collect();
+    pos.sort_by(|a, b| {
+        let r_a = a.0 / a.1;
+        let r_b = b.0 / b.1;
+        r_b.partial_cmp(&r_a).unwrap_or(core::cmp::Ordering::Equal)
+    });
+
+    let mut removed_weight = 0.0_f32;
+    for (ev, w) in pos {
+        if remaining <= 0.0 {
+            break;
+        }
+        if ev >= remaining {
+            removed_weight += w * (remaining / ev);
+            remaining = 0.0;
+        } else {
+            removed_weight += w;
+            remaining -= ev;
+        }
+    }
+    if remaining > 0.0 {
+        // Unreachable when `change_lower_bound = None` (which we already checked). Fall back
+        // to the loose `D_all`-based bound rather than fabricating a tight one.
+        return d_all_iw;
+    }
+    d_all_iw - removed_weight
+}