fix: make v2 compiler deterministic (#1420)

crates/recursion/compiler/src/circuit/compiler.rs

@@ -7,7 +7,13 @@ use p3_field::{
 use sp1_core_machine::utils::{sp1_debug_mode, SpanBuilder};
 use sp1_recursion_core::air::{Block, RecursionPublicValues, RECURSIVE_PROOF_NUM_PV_ELTS};
 use sp1_recursion_core_v2::{BaseAluInstr, BaseAluOpcode};
-use std::{borrow::Borrow, collections::HashMap, iter::repeat, mem::transmute};
+use std::{
+    borrow::Borrow,
+    cmp::Ordering,
+    collections::BTreeMap,
+    iter::repeat,
+    mem::{take, transmute},
+};
 use vec_map::VecMap;
 
 use sp1_recursion_core_v2::*;
@@ -21,7 +27,7 @@ pub struct AsmCompiler<C: Config> {
     /// Map the frame pointers of the variables to the "physical" addresses.
     pub virtual_to_physical: VecMap<Address<C::F>>,
     /// Map base or extension field constants to "physical" addresses and mults.
-    pub consts: HashMap<Imm<C::F, C::EF>, (Address<C::F>, C::F)>,
+    pub consts: BTreeMap<Imm<C::F, C::EF>, (Address<C::F>, C::F)>,
     /// Map each "physical" address to its read count.
     pub addr_to_mult: VecMap<C::F>,
 }
@@ -599,7 +605,7 @@ where
         debug_assert!(self.addr_to_mult.is_empty());
         // Initialize constants.
         let total_consts = self.consts.len();
-        let instrs_consts = self.consts.drain().map(|(imm, (addr, mult))| {
+        let instrs_consts = take(&mut self.consts).into_iter().map(|(imm, (addr, mult))| {
             Instruction::Mem(MemInstr {
                 addrs: MemIo { inner: addr },
                 vals: MemIo { inner: imm.as_block() },
@@ -661,6 +667,36 @@ pub enum Imm<F, EF> {
     EF(EF),
 }
 
+impl<F, EF> PartialOrd for Imm<F, EF>
+where
+    F: PartialEq + AbstractField + PartialOrd,
+    EF: PartialEq + AbstractExtensionField<F>,
+{
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        match (self, other) {
+            (Imm::F(a), Imm::F(b)) => a.partial_cmp(b),
+            (Imm::F(_), Imm::EF(_)) => Some(Ordering::Less),
+            (Imm::EF(_), Imm::F(_)) => Some(Ordering::Greater),
+            (Imm::EF(a), Imm::EF(b)) => a.as_base_slice().partial_cmp(b.as_base_slice()),
+        }
+    }
+}
+
+impl<F, EF> Ord for Imm<F, EF>
+where
+    F: Eq + AbstractField + Ord,
+    EF: Eq + AbstractExtensionField<F>,
+{
+    fn cmp(&self, other: &Self) -> Ordering {
+        match (self, other) {
+            (Imm::F(a), Imm::F(b)) => a.cmp(b),
+            (Imm::F(_), Imm::EF(_)) => Ordering::Less,
+            (Imm::EF(_), Imm::F(_)) => Ordering::Greater,
+            (Imm::EF(a), Imm::EF(b)) => a.as_base_slice().cmp(b.as_base_slice()),
+        }
+    }
+}
+
 impl<F, EF> Imm<F, EF>
 where
     F: AbstractField + Copy,