halfway change range constraints.

Author: chriseth

executor/src/witgen/data_structures/mutable_state.rs

@@ -55,8 +55,8 @@ impl<'a, T: FieldElement, Q: QueryCallback<T>> MutableState<'a, T, Q> {
         &self,
         identity_id: u64,
         known_inputs: &BitVec,
-        range_constraints: &[Option<RangeConstraint<T>>],
-    ) -> Option<Vec<Option<RangeConstraint<T>>>> {
+        range_constraints: &[RangeConstraint<T>],
+    ) -> Option<Vec<RangeConstraint<T>>> {
         // TODO We are currently ignoring bus interaction (also, but not only because there is no
         // unique machine responsible for handling a bus send), so just answer "false" if the identity
         // has no responsible machine.

executor/src/witgen/jit/witgen_inference.rs

@@ -246,6 +246,7 @@ impl<'a, T: FieldElement, FixedEval: FixedEvaluator<T>> WitgenInference<'a, T, F
         let range_constraints = evaluated
             .iter()
             .map(|e| e.as_ref().and_then(|e| e.range_constraint()))
+            .map(|rc| rc.unwrap_or_default())
             .collect_vec();
         let known = evaluated.iter().map(|e| e.is_some()).collect();
 
@@ -543,17 +544,17 @@ pub trait CanProcessCall<T: FieldElement> {
         &self,
         _identity_id: u64,
         _known_inputs: &BitVec,
-        _range_constraints: &[Option<RangeConstraint<T>>],
-    ) -> Option<Vec<Option<RangeConstraint<T>>>>;
+        _range_constraints: &[RangeConstraint<T>],
+    ) -> Option<Vec<RangeConstraint<T>>>;
 }
 
 impl<T: FieldElement, Q: QueryCallback<T>> CanProcessCall<T> for &MutableState<'_, T, Q> {
     fn can_process_call_fully(
         &self,
         identity_id: u64,
         known_inputs: &BitVec,
-        range_constraints: &[Option<RangeConstraint<T>>],
-    ) -> Option<Vec<Option<RangeConstraint<T>>>> {
+        range_constraints: &[RangeConstraint<T>],
+    ) -> Option<Vec<RangeConstraint<T>>> {
         MutableState::can_process_call_fully(self, identity_id, known_inputs, range_constraints)
     }
 }

executor/src/witgen/machines/double_sorted_witness_machine_32.rs

@@ -190,8 +190,8 @@ impl<'a, T: FieldElement> Machine<'a, T> for DoubleSortedWitnesses32<'a, T> {
         &mut self,
         identity_id: u64,
         known_arguments: &BitVec,
-        range_constraints: &[Option<RangeConstraint<T>>],
-    ) -> Option<Vec<Option<RangeConstraint<T>>>> {
+        range_constraints: &[RangeConstraint<T>],
+    ) -> Option<Vec<RangeConstraint<T>>> {
         assert!(self.parts.connections.contains_key(&identity_id));
         assert_eq!(known_arguments.len(), 4);
         assert_eq!(range_constraints.len(), 4);
@@ -206,16 +206,12 @@ impl<'a, T: FieldElement> Machine<'a, T> for DoubleSortedWitnesses32<'a, T> {
         // For the value, it depends: If we write, we need to know it, if we read we do not need to know it.
         if known_arguments[3] {
             // It is known, so we are good anyway.
-            Some(vec![None; 4])
+            Some(vec![RangeConstraint::unconstrained(); 4])
         } else {
             // It is not known, so we can only process if we do not write.
-            range_constraints[0]
-                .as_ref()
-                .is_some_and(|rc| {
-                    !rc.allows_value(T::from(OPERATION_ID_BOOTLOADER_WRITE))
-                        && !rc.allows_value(T::from(OPERATION_ID_WRITE))
-                })
-                .then(|| vec![None; 4])
+            (!range_constraints[0].allows_value(T::from(OPERATION_ID_BOOTLOADER_WRITE))
+                && !range_constraints[0].allows_value(T::from(OPERATION_ID_WRITE)))
+            .then(|| vec![RangeConstraint::unconstrained(); 4])
         }
     }
 

executor/src/witgen/machines/fixed_lookup_machine.rs

@@ -302,8 +302,8 @@ impl<'a, T: FieldElement> Machine<'a, T> for FixedLookup<'a, T> {
         &mut self,
         identity_id: u64,
         known_arguments: &BitVec,
-        range_constraints: &[Option<RangeConstraint<T>>],
-    ) -> Option<Vec<Option<RangeConstraint<T>>>> {
+        range_constraints: &[RangeConstraint<T>],
+    ) -> Option<Vec<RangeConstraint<T>>> {
         if !Self::is_responsible(&self.connections[&identity_id]) {
             return None;
         }

executor/src/witgen/machines/mod.rs

@@ -69,8 +69,8 @@ pub trait Machine<'a, T: FieldElement>: Send + Sync {
         &mut self,
         _identity_id: u64,
         _known_arguments: &BitVec,
-        _range_constraints: &[Option<RangeConstraint<T>>],
-    ) -> Option<Vec<Option<RangeConstraint<T>>>> {
+        _range_constraints: &[RangeConstraint<T>],
+    ) -> Option<Vec<RangeConstraint<T>>> {
         None
     }
 
@@ -189,8 +189,8 @@ impl<'a, T: FieldElement> Machine<'a, T> for KnownMachine<'a, T> {
         &mut self,
         identity_id: u64,
         known_arguments: &BitVec,
-        range_constraints: &[Option<RangeConstraint<T>>],
-    ) -> Option<Vec<Option<RangeConstraint<T>>>> {
+        range_constraints: &[RangeConstraint<T>],
+    ) -> Option<Vec<RangeConstraint<T>>> {
         match self {
             KnownMachine::SecondStageMachine(m) => {
                 m.can_process_call_fully(identity_id, known_arguments, range_constraints)

executor/src/witgen/range_constraints.rs

@@ -62,6 +62,15 @@ impl<T: FieldElement> RangeConstraint<T> {
         Self { mask, min, max }
     }
 
+    /// Returns a range constraint that allows any value.
+    pub fn unconstrained() -> Self {
+        Self {
+            mask: !T::Integer::zero(),
+            min: T::zero(),
+            max: T::from(-1),
+        }
+    }
+
     /// Returns a bit mask. This might be drastically under-fitted in case
     /// the constraint is more resembling an interval.
     /// Semantics: X & mask == X holds for all possible values of X.
@@ -202,6 +211,12 @@ impl<T: FieldElement> RangeConstraint<T> {
     }
 }
 
+impl<T: FieldElement> Default for RangeConstraint<T> {
+    fn default() -> Self {
+        Self::unconstrained()
+    }
+}
+
 /// The number of elements in an (inclusive) min/max range.
 /// Works both if min is smaller than max and if it is larger (the inverted interval).
 fn range_width<T: FieldElement>(min: T, max: T) -> T::Integer {