feat: simplify explicit equality assertions to assert equality directly

[TomAFrench]

Description

Problem*

Resolves

Summary*

This PR adds 3 optimisations.

1. x < 1 gets rewritten as x == 0 for unsigned values of x (as this is the only value for which x < 1 can be true)
2. constraining the result of an equality to be true gets rewritten as asserting this equality directly.
3. constraining the result of a boolean NOT gets rewritten to be in terms of the original value.

Additional Context

Documentation*

Check one:

• No documentation needed.
• Documentation included in this PR.
• [Exceptional Case] Documentation to be submitted in a separate PR.

PR Checklist*

• I have tested the changes locally.
• I have formatted the changes with Prettier and/or cargo fmt on default settings.

[github-actions]

Changes to circuit sizes

Generated at commit: 0bfb85e875b0b373c79e5d4261bf948bbae46905, compared to commit: 2c06a64e502bac6839375c5636d39a172a609a5f

🧾 Summary (10% most significant diffs)

Program	ACIR opcodes (+/-)	%	Circuit size (+/-)	%
tuple_inputs	-1 ✅	-1.82%	-3 ✅	-0.08%
pred_eq	-4 ✅	-80.00%	-3 ✅	-33.33%

---

Full diff report 👇

Program	ACIR opcodes (+/-)	%	Circuit size (+/-)	%
conditional_2	20 (-1)	-4.76%	2,764 (-1)	-0.04%
tuple_inputs	54 (-1)	-1.82%	3,686 (-3)	-0.08%
pred_eq	1 (-4)	-80.00%	6 (-3)	-33.33%

[jfecher]

I don't like that we have optimizations taking place only on the assert version of lhs == rhs, it seems the design of assert is forcing us to duplicate this logic. It also seems like there are bugs stemming from it as well (see: #3740). Maybe we should consider moving back to Instruction::Assert(bool, msg), and checking for the equality optimization for assert_eq in acir-gen instead.

[TomAFrench]

One benefit of having a binary rather than unary constraint instruction is that it's easier to use this information to inform simplifications to later SSA instructions. e.g. If I constrain v1 == 0 then with a binary constraint instruction then I know I can replace all instances of v1 with the constant 0 (subject to side effects), otherwise I would have to back this information through the equality instructions to discover that v1 == 0.

A binary constraint instruction also helps reduce constraints necessary for asserting the equality of more complex types such as arrays as it can be converted into a direct assertion over each field rather than having to construct a predicate first.

[jfecher]

LGTM we can revisit the binary versus unary constrain in a later issue