Repository navigation
SMT2: compare fixed-size arrays element by element - #9230
Open
tautschnig wants to merge 1 commit into
Open
tautschnig wants to merge 1 commit into
tautschnig wants to merge 1 commit into
Conversation
SMT-LIB (= a b) on two arrays compares them on the entire index domain. Only the indices 0..size-1 of a C array are constrained, though, so the solver may pick different values for the elements out of bounds, and __CPROVER_equal or __CPROVER_array_equal on two arrays with equal elements fails spuriously. The propositional back-end does not have this problem as it flattens such arrays. For arrays of constant size up to MAX_FLATTENED_ARRAY_SIZE, the bound the propositional back-end uses for flattening, encode the equality as the conjunction of the equalities of the elements. Both operands are bound once via let, so that they are not repeated per element. Larger arrays keep the previous encoding. This addresses the array case of diffblue#9211. Arrays that are members of a struct encoded as an SMT-LIB datatype (with Z3 or cvc5) are compared as part of the datatype value and are not covered by this change. Co-authored-by: Kiro <kiro-agent@users.noreply.github.com>
tautschnig
requested review from
TGWDB,
kroening,
martin-cs and
peterschrammel
as code owners
October 20, 2026 19:39
There was a problem hiding this comment.
Copilot was unable to review this pull request because the user who requested the review has reached their quota limit.
An organization owner can choose the repository organization as the billing source for reviews requested by members with a paid Copilot license. Learn about Copilot code review billing. Review the Copilot code review billing settings.
Codecov Report✅ All modified and coverable lines are covered by tests. Additional details and impacted files@@ Coverage Diff @@
## develop #9230 +/- ##
===========================================
- Coverage 80.91% 80.90% -0.01%
===========================================
Files 1718 1718
Lines 190266 190290 +24
Branches 73 73
===========================================
+ Hits 153952 153957 +5
- Misses 36314 36333 +19 ☔ View full report in Codecov by Harness. 🚀 New features to boost your workflow:
|
TGWDB
approved these changes
Oct 21, 2026
Collaborator
|
There needs to be a better way here, other than enumerating up to magic constant? |
This branch has not been deployed
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
SMT-LIB (= a b) on two arrays compares them on the entire index domain.
Only the indices 0..size-1 of a C array are constrained, though, so the
solver may pick different values for the elements out of bounds, and
__CPROVER_equal or __CPROVER_array_equal on two arrays with equal
elements fails spuriously. The propositional back-end does not have this
problem as it flattens such arrays.
For arrays of constant size up to MAX_FLATTENED_ARRAY_SIZE, the bound
the propositional back-end uses for flattening, encode the equality as
the conjunction of the equalities of the elements. Both operands are
bound once via let, so that they are not repeated per element. Larger
arrays keep the previous encoding.
This addresses the array case of #9211. Arrays that are members of a
struct encoded as an SMT-LIB datatype (with Z3 or cvc5) are compared as
part of the datatype value and are not covered by this change.