onedimensional: add full-bin, perfect-pair, dominant-set, lift, bin-shrinking and dominated-bin-type reductions

[fontanf]

Extends the onedimensional Reduction with dedicated-bin reservations and ports of the remaining rectangle operations.

New operations

• Full-bin items / perfect pairs (reduce_full_bin_items, reduce_perfect_pairs): an item type whose length matches the bin, or a pair whose lengths sum to it, gets a dedicated bin.

• Dominant sets (reduce_dominant_sets): the Martello-Toth reduction procedure. For each free item, by decreasing length, look for a set of items that fits beside it and dominates every other such set, and reserve them a dedicated bin, until nothing more can be fixed. Three rules are checked:

  • everything fitting beside the item fits together;
  • a single item exactly fills the space, or no two items fit together beside it;
  • a pair, when no three items fit together beside it and no two items longer than the second one do either.

  Identical dedicated bins are grouped into a single record.

• Item length lifting (lift_item_lengths): grow a single-copy item type's length to close a margin no combination of the other items could ever fill. The bound uses subsetsumsolver::dynamic_programming_bellman_word_ram (new dependency, pinned to the commit with the out-of-bounds fix, Fix out-of-bounds read in dynamic_programming_bellman_word_ram subsetsumsolver#1). Nesting items count at their smallest footprint, so the bound is never underestimated. Not for Knapsack and BinPackingWithLeftovers.

• Bin shrinking (shrink_bin, port of rectangle's compute_shrunk_bin_sizes): the operations above reason against the largest length the remaining items can fill instead of the bin's true length, recomputed as items get reserved. The reduced instance keeps the true bin length.

• Dominated bin types (remove_dominated_bin_types, port of rectangle's operation): for Knapsack, Feasibility and VariableSizedBinPacking with several bin types. The dominating bin type must have as many copies as the number of items plus its own copies_min. unreduce_solution maps bin type ids back to the original instance.

• Classical knapsack: for a single-bin knapsack with no constraint beyond lengths and copies, only remove_negative_profit_items is applied, since the knapsack primal-dual dynamic programming already performs the useful reductions. Other single-bin knapsacks still get every applicable reduction, since the dynamic programming only relaxes them there.

Soundness of the dedicated-bin reductions

The dedicated-bin reductions rely on an exchange argument that moves the other items of an optimal solution between bins. So full_bin_reduction_applies requires every item type of the instance, not only the reserved ones, to have no nesting length, no finite maximum_weight_after and no binding maximum_stackability. For example, with bin length 10, items 6 and 4, and two items of length 7 with nesting length 3, reserving the perfect pair {6, 4} gives 3 bins (and is reported as optimal), while {6, 7} and {4, 7} only need 2. This case is now a regression test.

Testing

• Onedimensional unit tests: 61/61 pass. New reduction fixtures cover each rule of the dominant-set reduction, lifting with nesting items, bin shrinking, dominated bin types (including the bin type id mapping in unreduce_solution), the classical-knapsack case, and the nesting counterexample above.
• Random cross-check: 1,500 small BinPacking instances, solved with and without the reduction. No mismatch attributable to the reduction. The remaining mismatches come from two existing solver issues with nesting, not addressed here:
  • Solution does not clamp an item's start at 0, so a nesting item longer than its predecessor can start before the bin.
  • Some lower bound ignores nesting: bin length 16 with items 14 and (3, nesting 1) gets a dual bound of 2, although both fit in one bin.