fix(consensus): short-circuit Coll-equality cost at first mismatch (Scala parity)

[arkadianet]

Why

EQ/NEQ on a primitive collection (Coll[Byte]/Bool/Int/Long/Short, SString) charged the per-item cost over the full left-operand length, but Scala's DataValueComparer.equalCOA_Prim short-circuits both value and cost at the first unequal element — billing PerItemCost over the compared prefix (the loop's returned count i, via addSeqCost). For two equal-length colls differing at index k<len, Scala bills chunks(k+1); we billed chunks(len).

Over-charge only (never under) → a reject-valid risk: an input whose true cost sits just under the tx/block cost limit but whose collection equality short-circuits early could be over-billed past the limit and rejected where Scala accepts. Coll[Byte] equality (token ids, propositionBytes, digests) is pervasive.

What

Split the typed-Coll arm of eq_with_cost_inner: the primitive carriers walk both arrays, stop at the first unequal element, and charge the per-type PerItemCost over that compared prefix — mirroring eq_coll_fallback/CollSigmaProp, which already track k_eff. All-equal and length-mismatch costs are unchanged. Box/Header/Tokens colls (Scala equalColls path) are untouched.

Test plan

• RED/GREEN unit tests (prim_coll_eq_tests): early-mismatch costs < late-mismatch; all-equal == last-element-mismatch (full length); length-mismatch bills only MatchType.
• cargo fmt ✓, clippy --all-targets --all-features -D warnings ✓, cargo test --all ✓.
• SANTA conformance: clears the 3 Coll.eq_compared_count_coa coals (mismatch-at-0/150/300), no new coals.

Note

The earlier triage lumped 17 h* block-input vectors into this cluster. Verified post-fix: their +1/+2 cost deltas are unchanged by this change — they're a separate cost-model divergence (value byte-identical), not the Coll-eq short-circuit. They need their own root-cause and are not addressed here.

🤖 Generated with Claude Code

Summary by CodeRabbit

• Performance Improvements
  • Improved equality comparisons for primitive collections to stop at the first mismatch, reducing work on large structures.
• Correctness / Cost Accounting
  • Refined the comparison cost behavior so pricing now reflects only the successfully compared prefix; if lengths differ, the result is determined after charging only the base match cost.
  • Non-primitive string and related types keep the previous full-length cost behavior.
• Tests
  • Added coverage to verify early vs. late mismatches and length-mismatch scenarios.

[coderabbitai]

No actionable comments were generated in the recent review. 🎉

ℹ️ Recent review info

⚙️ Run configuration

Configuration used: defaults

Review profile: CHILL

Plan: Pro

Run ID: 637dcd75-4a3f-4825-a61c-9d93af716079

📥 Commits

Reviewing files that changed from the base of the PR and between c2568a6 and 7790a8f.

📒 Files selected for processing (1)

• ergo-sigma/src/evaluator/cost.rs

---

📝 Walkthrough

Walkthrough

eq_with_cost_inner in cost.rs is updated to implement Scala equalCOA_Prim semantics for primitive collection carriers (CollBytes, CollBool, CollShort, CollInt, CollLong). Cost and value comparison now short-circuit at the first unequal element, charging MATCH_TYPE unconditionally then PerItemCost only over the compared prefix. Two private helpers and a unit-test module are added.

Changes

Primitive collection equality short-circuit cost

Layer / File(s)	Summary
Helper functions and dispatch routing ergo-sigma/src/evaluator/cost.rs	Adds prim_coll_eq charging MATCH_TYPE plus PerItemCost(15, 2, chunk_size) over the compared prefix length with early return on mismatch, and prim_coll_eq_fallback for mismatched carriers. Updates eq_with_cost_inner match arms to route primitive collection types through these helpers with per-type chunk_size, while explicitly excluding Str, CollBox, CollHeader, and Tokens from the short-circuit path.
Unit tests for prim_coll_eq cost behavior ergo-sigma/src/evaluator/cost.rs	Adds prim_coll_eq_tests validating early vs late mismatch cost scaling, all-equal cost matching full-length mismatch cost, length mismatch charging only MATCH_TYPE, empty collection cost, and cross-chunk-size short-circuit behavior for multiple chunk sizes.

Estimated code review effort

🎯 3 (Moderate) | ⏱️ ~20 minutes

Possibly related PRs

• arkadianet/ergo#30: Introduced eq_with_cost/eq_with_cost_inner for Scala-faithful EQ/NEQ cost modeling — the direct predecessor to this PR's eq_with_cost_inner primitive collection dispatch changes.

Poem

🐇 Hop, hop, short-circuit away,
No need to check every byte today!
First mismatch found? We stop right there,
Charging only the cost we dare.
Less work for the rabbit, more speed to spare! 🥕

🚥 Pre-merge checks | ✅ 5

✅ Passed checks (5 passed)

Check name	Status	Explanation
Description Check	✅ Passed	Check skipped - CodeRabbit’s high-level summary is enabled.
Title check	✅ Passed	The title clearly and concisely summarizes the main change: implementing short-circuit cost calculation for Coll-equality comparisons to match Scala behavior.
Docstring Coverage	✅ Passed	Docstring coverage is 100.00% which is sufficient. The required threshold is 80.00%.
Linked Issues check	✅ Passed	Check skipped because no linked issues were found for this pull request.
Out of Scope Changes check	✅ Passed	Check skipped because no linked issues were found for this pull request.

_{✏️ Tip: You can configure your own custom pre-merge checks in the settings.}

✨ Finishing Touches

📝 Generate docstrings

• Create stacked PR
• Commit on current branch

🧪 Generate unit tests (beta)

• Create PR with unit tests
• Commit unit tests in branch fix/colleq-cost-shortcircuit

---

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

• X
• Mastodon
• Reddit
• LinkedIn

_{Comment @coderabbitai help to get the list of available commands and usage tips.}

[coderabbitai]

🧹 Nitpick comments (1)

ergo-sigma/src/evaluator/cost.rs (1)

680-743: 💤 Low value

Consider adding test coverage for empty collections and varying chunk sizes.

The tests comprehensively validate the short-circuit behavior for CollBytes, but all three use the same chunk size (128). Since the prim_coll_eq function is generic and handles different chunk sizes (96 for Short, 64 for Int, 48 for Long), a test verifying that early-mismatch savings scale correctly with chunk size would strengthen confidence in the per-item cost formula.

Additionally, the empty collection case (k_eff = 0) is untested. While the logic appears correct, an explicit assertion that eq_cost(&[], &[]) returns the expected cost (MATCH_TYPE + base cost for 0 items) would document the behavior.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@ergo-sigma/src/evaluator/cost.rs` around lines 680 - 743, Add two new test
functions within the prim_coll_eq_tests module to extend coverage. First, add a
test for empty collections that calls eq_cost with empty byte slices and asserts
the cost matches the expected MATCH_TYPE plus base cost for zero items. Second,
add a parametrized or separate test function that verifies the early-mismatch
cost savings behavior with different chunk sizes (96, 64, and 48) to ensure the
per-item cost formula scales correctly across different collection types,
similar to the existing collbytes_eq_cost_short_circuits_at_first_mismatch test
but using vectors of varying lengths appropriate to each chunk size.

🤖 Prompt for all review comments with AI agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Nitpick comments:
In `@ergo-sigma/src/evaluator/cost.rs`:
- Around line 680-743: Add two new test functions within the prim_coll_eq_tests
module to extend coverage. First, add a test for empty collections that calls
eq_cost with empty byte slices and asserts the cost matches the expected
MATCH_TYPE plus base cost for zero items. Second, add a parametrized or separate
test function that verifies the early-mismatch cost savings behavior with
different chunk sizes (96, 64, and 48) to ensure the per-item cost formula
scales correctly across different collection types, similar to the existing
collbytes_eq_cost_short_circuits_at_first_mismatch test but using vectors of
varying lengths appropriate to each chunk size.

---

ℹ️ Review info

⚙️ Run configuration

Configuration used: defaults

Review profile: CHILL

Plan: Pro

Run ID: bc119b51-4856-4935-acff-7d33dd6c8439

📥 Commits

Reviewing files that changed from the base of the PR and between 4c54531 and c2568a6.

📒 Files selected for processing (1)

• ergo-sigma/src/evaluator/cost.rs

[arkadianet]

Addressed the test-coverage nitpick in 7790a8f: added collbytes_eq_cost_empty_collections (k_eff=0 → MatchType + base) and prim_coll_eq_short_circuits_across_chunk_sizes (verifies the short-circuit holds for the Short=96 / Int=64 / Long=48 chunk sizes, not just CollBytes=128). Also folded in the earlier P1 fix (SString stays full-length, not short-circuited). Branch rebased onto current main.