optimize duplicate-heavy exact block evaluation

Author: OpusNano

docs/progress.md

@@ -23,6 +23,7 @@ This document tracks the next correctness-first phase as repository-visible work
 - [x] Config-matrix differential and invariant test layer added
 - [x] Local benchmark harness and first measured optimization pass added
 - [x] Exact acceptance-cost optimization using permutation delta energy added
+- [x] Duplicate-aware grouped exact evaluator path added
 
 ## Active next-phase checklist
 
@@ -59,6 +60,7 @@ This document tracks the next correctness-first phase as repository-visible work
 - keep benchmark datasets aligned with correctness stress patterns
 - use benchmark observations to justify small, auditable optimization passes
 - continue reducing transport acceptance cost without weakening exactness
+- improve duplicate-heavy paths without regressing transport-first semantics
 
 ### Docs and positioning
 

src/core/energy.zig

@@ -1,6 +1,66 @@
 const Config = @import("config.zig").Config;
 const key = @import("key.zig");
 
+pub fn collectDistinctGroups(
+    comptime T: type,
+    keys: []const key.KeyType(T),
+    distinct_keys_out: []key.KeyType(T),
+    group_ids_out: []u8,
+) usize {
+    var distinct_count: usize = 0;
+
+    for (keys) |value| {
+        var found = false;
+        for (distinct_keys_out[0..distinct_count]) |existing| {
+            if (existing == value) {
+                found = true;
+                break;
+            }
+        }
+        if (!found) {
+            distinct_keys_out[distinct_count] = value;
+            distinct_count += 1;
+        }
+    }
+
+    var i: usize = 1;
+    while (i < distinct_count) : (i += 1) {
+        const current = distinct_keys_out[i];
+        var j = i;
+        while (j > 0 and distinct_keys_out[j - 1] > current) : (j -= 1) {
+            distinct_keys_out[j] = distinct_keys_out[j - 1];
+        }
+        distinct_keys_out[j] = current;
+    }
+
+    for (keys, 0..) |value, idx| {
+        var group: usize = 0;
+        while (group < distinct_count and distinct_keys_out[group] != value) : (group += 1) {}
+        group_ids_out[idx] = @intCast(group);
+    }
+
+    return distinct_count;
+}
+
+pub fn buildGroupWeightMatrix(
+    comptime T: type,
+    distinct_keys: []const key.KeyType(T),
+    cfg: Config,
+    weight_matrix: []u16,
+) void {
+    const stride = distinct_keys.len;
+    for (distinct_keys, 0..) |left_key, i| {
+        for (distinct_keys, 0..) |right_key, j| {
+            const index = i * stride + j;
+            if (left_key > right_key) {
+                weight_matrix[index] = @intCast(pairWeightFromKeys(T, left_key, right_key, cfg));
+            } else {
+                weight_matrix[index] = 0;
+            }
+        }
+    }
+}
+
 pub fn pairWeight(comptime T: type, left: T, right: T, cfg: Config) u64 {
     return 1 + key.closenessBonus(T, left, right, cfg);
 }
@@ -41,6 +101,24 @@ pub fn blockEnergyFromKeys(comptime T: type, keys: []const key.KeyType(T), cfg:
     return total;
 }
 
+pub fn blockEnergyFromGroupIds(group_ids: []const u8, distinct_count: usize, weight_matrix: []const u16) u64 {
+    var counts: [Config.max_block_size]usize = [_]usize{0} ** Config.max_block_size;
+    var total: u64 = 0;
+
+    var idx = group_ids.len;
+    while (idx > 0) {
+        idx -= 1;
+        const group = group_ids[idx];
+        var smaller: usize = 0;
+        while (smaller < group) : (smaller += 1) {
+            total += @as(u64, counts[smaller]) * weight_matrix[@as(usize, group) * distinct_count + smaller];
+        }
+        counts[group] += 1;
+    }
+
+    return total;
+}
+
 pub fn energyAfterPermutationFromKeys(
     comptime T: type,
     keys: []const key.KeyType(T),

src/core/transport.zig

@@ -19,6 +19,32 @@ fn useMovedDeltaPath(block_len: usize, moved_count: usize) bool {
     return affected_pairs * 2 < total_pairs;
 }
 
+fn useGroupedExactPath(block_len: usize, distinct_count: usize) bool {
+    return distinct_count <= 8 and distinct_count * 4 <= block_len;
+}
+
+fn cheapDistinctCount(comptime T: type, keys: []const key.KeyType(T)) usize {
+    const table_len = Config.max_block_size * 2;
+    var used: [table_len]bool = [_]bool{false} ** table_len;
+    var table: [table_len]key.KeyType(T) = undefined;
+    var count: usize = 0;
+
+    for (keys) |value| {
+        var hash: usize = @intCast(value ^ (value >> @min(@bitSizeOf(key.KeyType(T)) / 2, 16)));
+        hash %= table_len;
+        while (used[hash]) : (hash = (hash + 1) % table_len) {
+            if (table[hash] == value) break;
+        }
+        if (!used[hash]) {
+            used[hash] = true;
+            table[hash] = value;
+            count += 1;
+        }
+    }
+
+    return count;
+}
+
 fn isPermutation(mapping: []const usize) bool {
     var seen: [Config.max_block_size]bool = [_]bool{false} ** Config.max_block_size;
     for (mapping) |value| {
@@ -76,8 +102,26 @@ pub fn tryTransportBlock(comptime T: type, block: []T, cfg: Config, stats: ?*Sta
     var desired: [Config.max_block_size]usize = undefined;
     var source_to_final: [Config.max_block_size]usize = undefined;
     var moved_indices: [Config.max_block_size]usize = undefined;
+    var group_ids: [Config.max_block_size]u8 = undefined;
+    var final_group_ids: [Config.max_block_size]u8 = undefined;
+    var distinct_keys: [Config.max_block_size]key.KeyType(T) = undefined;
+    var weight_matrix: [Config.max_block_size * Config.max_block_size]u16 = undefined;
+
+    const estimated_distinct = cheapDistinctCount(T, keys[0..block.len]);
+    const grouped_path = useGroupedExactPath(block.len, estimated_distinct);
+    const distinct_count = if (grouped_path)
+        energy.collectDistinctGroups(T, keys[0..block.len], distinct_keys[0..block.len], group_ids[0..block.len])
+    else
+        0;
 
-    const before_energy = pressure.computeFromKeysWithEnergy(T, keys[0..block.len], cfg, pressures[0..block.len]);
+    const before_energy = if (grouped_path)
+        blk: {
+            energy.buildGroupWeightMatrix(T, distinct_keys[0..distinct_count], cfg, weight_matrix[0 .. distinct_count * distinct_count]);
+            pressure.computeFromKeys(T, keys[0..block.len], cfg, pressures[0..block.len]);
+            break :blk energy.blockEnergyFromGroupIds(group_ids[0..block.len], distinct_count, weight_matrix[0 .. distinct_count * distinct_count]);
+        }
+    else
+        pressure.computeFromKeysWithEnergy(T, keys[0..block.len], cfg, pressures[0..block.len]);
     if (before_energy == 0) {
         if (stats) |s| s.transport_blocks_rejected += 1;
         return .{ .accepted = false, .before_energy = before_energy, .after_energy = before_energy };
@@ -116,7 +160,14 @@ pub fn tryTransportBlock(comptime T: type, block: []T, cfg: Config, stats: ?*Sta
         return .{ .accepted = false, .before_energy = before_energy, .after_energy = before_energy };
     }
 
-    const after_energy = if (useMovedDeltaPath(block.len, moved_count))
+    const after_energy = if (grouped_path)
+        blk: {
+            for (group_ids[0..block.len], 0..) |group, source_index| {
+                final_group_ids[source_to_final[source_index]] = group;
+            }
+            break :blk energy.blockEnergyFromGroupIds(final_group_ids[0..block.len], distinct_count, weight_matrix[0 .. distinct_count * distinct_count]);
+        }
+    else if (useMovedDeltaPath(block.len, moved_count))
         energy.energyAfterPermutationFromMovedKeys(
             T,
             keys[0..block.len],

test/unit/energy_test.zig

@@ -59,3 +59,20 @@ test "moved-only permutation delta energy matches exact recomputation" {
 
     try std.testing.expectEqual(after_exact, after_delta);
 }
+
+test "grouped energy matches exact recomputation on duplicate-heavy block" {
+    const cfg = Config{ .valuation_cap = 8 };
+    const xs = [_]i32{ 2, 2, 1, 1, 0, 0, 2, 1 };
+    var keys = [_]key.KeyType(i32){ 0, 0, 0, 0, 0, 0, 0, 0 };
+    var distinct_keys = [_]key.KeyType(i32){0} ** 8;
+    var group_ids = [_]u8{0} ** 8;
+    var weights = [_]u16{0} ** (8 * 8);
+
+    for (xs, 0..) |value, i| keys[i] = key.biasedKey(i32, value);
+    const distinct_count = energy.collectDistinctGroups(i32, keys[0..], distinct_keys[0..], group_ids[0..]);
+    energy.buildGroupWeightMatrix(i32, distinct_keys[0..distinct_count], cfg, weights[0 .. distinct_count * distinct_count]);
+
+    const exact = energy.blockEnergy(i32, xs[0..], cfg);
+    const grouped = energy.blockEnergyFromGroupIds(group_ids[0..], distinct_count, weights[0 .. distinct_count * distinct_count]);
+    try std.testing.expectEqual(exact, grouped);
+}