refactor(sol): reduce local variables in SortMergeJoinExec (#1107)

Please be sure to look over the pull request guidelines here:
https://github.com/spaceandtimelabs/sxt-proof-of-sql/blob/main/CONTRIBUTING.md#submit-pr.

# Please go through the following checklist
- [ ] The PR title and commit messages adhere to guidelines here:
https://github.com/spaceandtimelabs/sxt-proof-of-sql/blob/main/CONTRIBUTING.md.
In particular `!` is used if and only if at least one breaking change
has been introduced.
- [ ] I have run the ci check script with `source
scripts/run_ci_checks.sh`.
- [ ] I have run the clean commit check script with `source
scripts/check_commits.sh`, and the commit history is certified to follow
clean commit guidelines as described here:
https://github.com/spaceandtimelabs/sxt-proof-of-sql/blob/main/COMMIT_GUIDELINES.md
- [ ] The latest changes from `main` have been incorporated to this PR
by simple rebase if possible, if not, then conflicts are resolved
appropriately.

# Rationale for this change

The proof of sql contracts repo needs there to be fewer local variables
in `SortMergeJoinExec`.

# What changes are included in this PR?

Adding s struct-like object within `SortMergeJoinExec` to reduce local
variables.

# Are these changes tested?
Yes.

Author: stuarttimwhite

solidity/src/proof_plans/SortMergeJoinExec.presl

@@ -188,7 +188,7 @@ library SortMergeJoinExec {
 
             // Assembles the collection of output columns that will be compared to the right hat collection.
             // Additionally, computes the i_eval
-            function consume_right_evals_for_join(builder_ptr, num_join_columns, hat_evals, res_chi_eval, chi_eval, left_right_and_output_evaluations) -> i_eval, right_output_column_evals {
+            function consume_right_evals_for_join(builder_ptr, num_join_columns, hat_evals, left_right_and_output_evaluations) -> i_eval, right_output_column_evals {
                 // The length of hat_evals is the length of the collection which will be used in the membership check
                 let num_hat_columns := mload(hat_evals)
                 right_output_column_evals := mload(FREE_PTR)
@@ -250,11 +250,11 @@ library SortMergeJoinExec {
             // Consumes the output evaluations from the first round builder for any output columns that belong only to the right plan 
             // and verifies that all output rows from the right plan are all members of the right hat collection.
             // Additionally, this function retrieves i_eval
-            function consume_and_membership_check_right_column_evals(builder_ptr, alpha_and_beta, num_join_columns, hat_evals, res_chi_eval, chi_eval, left_right_and_output_evaluations) -> i_eval {
+            function consume_and_membership_check_right_column_evals(builder_ptr, alpha_and_beta, num_join_columns, hat_evals, right_and_output_chi_evals, left_right_and_output_evaluations) -> i_eval {
                 let right_column_evals
                 i_eval, right_column_evals :=
                     consume_right_evals_for_join(
-                        builder_ptr, num_join_columns, hat_evals, res_chi_eval, chi_eval, left_right_and_output_evaluations
+                        builder_ptr, num_join_columns, hat_evals, left_right_and_output_evaluations
                     )
 
                 // Finally, we can do our membership check
@@ -263,8 +263,8 @@ library SortMergeJoinExec {
                         builder_ptr,
                         mload(alpha_and_beta),
                         mload(add(alpha_and_beta, WORD_SIZE)),
-                        chi_eval,
-                        res_chi_eval,
+                        mload(right_and_output_chi_evals),
+                        mload(add(right_and_output_chi_evals, WORD_SIZE)),
                         hat_evals,
                         right_column_evals
                     )
@@ -290,7 +290,7 @@ library SortMergeJoinExec {
             // for any columns that belong only to the right plan, and verifies that all output rows from the right plan
             // are all members of the right hat collection.
             // Additionally, this function checks the monotonicity of the i_eval
-            function evaluate_consume_and_check_right_join_evals(plan_ptr, builder_ptr, alpha_and_beta, res_chi_eval, left_right_and_output_evaluations, chi_eval) -> plan_ptr_out {
+            function evaluate_consume_and_check_right_join_evals(plan_ptr, builder_ptr, alpha_and_beta, left_right_and_output_evaluations, right_and_output_chi_evals) -> plan_ptr_out {
                 let hat_evals, i_eval, join_evals
                 plan_ptr, hat_evals, join_evals :=
                     evaluate_input_plans(plan_ptr, builder_ptr, mload(add(left_right_and_output_evaluations, WORD_SIZE)))
@@ -300,8 +300,7 @@ library SortMergeJoinExec {
                         alpha_and_beta,
                         mload(join_evals),
                         hat_evals,
-                        res_chi_eval,
-                        chi_eval,
+                        right_and_output_chi_evals,
                         left_right_and_output_evaluations
                     )
                 mstore(add(left_right_and_output_evaluations, WORD_SIZE), join_evals)
@@ -311,7 +310,7 @@ library SortMergeJoinExec {
                     mload(alpha_and_beta),
                     mload(add(alpha_and_beta, WORD_SIZE)),
                     i_eval,
-                    res_chi_eval,
+                    mload(add(right_and_output_chi_evals, WORD_SIZE)),
                     1,
                     1
                 )
@@ -350,9 +349,10 @@ library SortMergeJoinExec {
             }
 
             // This function is effectively any verification that happens on the evaluations of the left and right input plans
-            function evaluate_sort_merge_join_outputs(plan_ptr, builder_ptr, left_right_and_output_evaluations, left_chi_eval, right_chi_eval, output_chi_eval) -> plan_ptr_out {
+            function evaluate_sort_merge_join_outputs(plan_ptr, builder_ptr, left_right_and_output_evaluations, left_chi_eval, right_and_output_chi_evals) -> plan_ptr_out {
                 // In order to save on local variables, we save alpha and beta in one location in memory
                 let alpha_and_beta := mload(FREE_PTR)
+                let output_chi_eval := mload(add(right_and_output_chi_evals, WORD_SIZE))
                 mstore(FREE_PTR, add(alpha_and_beta, WORDX2_SIZE))
                 mstore(alpha_and_beta, builder_consume_challenge(builder_ptr))
                 mstore(add(alpha_and_beta, WORD_SIZE), builder_consume_challenge(builder_ptr))
@@ -370,9 +370,8 @@ library SortMergeJoinExec {
                         plan_ptr,
                         builder_ptr,
                         alpha_and_beta,
-                        output_chi_eval,
                         left_right_and_output_evaluations,
-                        right_chi_eval
+                        right_and_output_chi_evals
                     )
 
                 let w_eval
@@ -383,7 +382,7 @@ library SortMergeJoinExec {
                         alpha_and_beta,
                         left_right_and_output_evaluations,
                         left_chi_eval,
-                        right_chi_eval
+                        mload(right_and_output_chi_evals)
                     )
                 // sum w_eval - output_chi_eval = 0
                 builder_produce_zerosum_constraint(builder_ptr, submod_bn254(w_eval, output_chi_eval), 2)
@@ -408,28 +407,31 @@ library SortMergeJoinExec {
                 let left_right_and_output_evaluations := mload(FREE_PTR)
                 mstore(FREE_PTR, add(left_right_and_output_evaluations, WORDX3_SIZE))
 
-                let left_chi_eval, right_chi_eval
+                let left_chi_eval
                 {
                     let left_evaluations, left_output_length
                     plan_ptr, left_evaluations, left_output_length, left_chi_eval :=
                         proof_plan_evaluate(plan_ptr, builder_ptr)
                     mstore(left_right_and_output_evaluations, left_evaluations)
                 }
+                let right_and_output_chi_evals := mload(FREE_PTR)
+                mstore(FREE_PTR, add(right_and_output_chi_evals, WORDX2_SIZE))
                 {
-                    let right_evaluations, right_output_length
+                    let right_evaluations, right_output_length, right_chi_eval
                     plan_ptr, right_evaluations, right_output_length, right_chi_eval :=
                         proof_plan_evaluate(plan_ptr, builder_ptr)
+                    mstore(right_and_output_chi_evals, right_chi_eval)
                     mstore(add(left_right_and_output_evaluations, WORD_SIZE), right_evaluations)
                 }
                 output_length, output_chi_eval := builder_consume_chi_evaluation_with_length(builder_ptr)
+                mstore(add(right_and_output_chi_evals, WORD_SIZE), output_chi_eval)
                 plan_ptr :=
                     evaluate_sort_merge_join_outputs(
                         plan_ptr,
                         builder_ptr,
                         left_right_and_output_evaluations,
                         left_chi_eval,
-                        right_chi_eval,
-                        output_chi_eval
+                        right_and_output_chi_evals
                     )
                 evaluations_ptr := mload(add(left_right_and_output_evaluations, WORDX2_SIZE))