Implement u32assert_lt instruction

CHANGELOG.md

@@ -8,6 +8,7 @@
 - Introduced the `procref.<proc_name>` assembly instruction (#1113).
 - Added the ability to use constants as counters in `repeat` loops (#1124). 
 - All `checked` versions of the u32 instructions were removed. All `unchecked` versions were renamed: this mode specification was removed from their titles (#1115).
+- Introduced the `u32assert_lt` assembly instruction (#1157).
 
 #### Stdlib
 - Introduced `std::utils` module with `is_empty_word` procedure.  Refactored `std::collections::smt`

assembly/src/assembler/instruction/mod.rs

@@ -108,6 +108,8 @@ impl Assembler {
             Instruction::U32AssertWWithError(err_code) => {
                 u32_ops::u32assertw(span, Felt::from(*err_code))
             }
+            Instruction::U32AssertLt => u32_ops::u32assert_lt(span, None),
+            Instruction::U32AssertLtImm(v) => u32_ops::u32assert_lt(span, Some(*v)),
 
             Instruction::U32Cast => span.add_ops([U32split, Drop]),
             Instruction::U32Split => span.add_op(U32split),

assembly/src/assembler/instruction/u32_ops.rs

@@ -66,6 +66,22 @@ pub fn u32assertw(
     span.add_ops(ops)
 }
 
+/// Translates u32assert_lt assembly instructions to VM operations.
+///
+/// This takes 6 VM cycles.
+pub fn u32assert_lt(
+    span: &mut SpanBuilder,
+    imm: Option<u32>,
+) -> Result<Option<CodeBlock>, AssemblyError> {
+    if let Some(imm) = imm {
+        span.push_ops([Dup0, Push(Felt::from(imm))]);
+    } else {
+        span.push_ops([Dup1, Dup1]);
+    }
+    u32lt(span)?;
+    span.add_op(Assert(ZERO))
+}
+
 // ARITHMETIC OPERATIONS
 // ================================================================================================
 
@@ -384,7 +400,7 @@ fn prepare_bitwise<const MAX_VALUE: u8>(
 
 /// Translates u32lt assembly instructions to VM operations.
 ///
-/// This operation takes 5 cycles.
+/// This operation takes 3 cycles.
 pub fn u32lt(span: &mut SpanBuilder) -> Result<Option<CodeBlock>, AssemblyError> {
     compute_lt(span);
 
@@ -393,7 +409,7 @@ pub fn u32lt(span: &mut SpanBuilder) -> Result<Option<CodeBlock>, AssemblyError>
 
 /// Translates u32lte assembly instructions to VM operations.
 ///
-/// This operation takes 7 cycles.
+/// This operation takes 5 cycles.
 pub fn u32lte(span: &mut SpanBuilder) -> Result<Option<CodeBlock>, AssemblyError> {
     // Compute the lt with reversed number to get a gt check
     span.push_op(Swap);
@@ -405,7 +421,7 @@ pub fn u32lte(span: &mut SpanBuilder) -> Result<Option<CodeBlock>, AssemblyError
 
 /// Translates u32gt assembly instructions to VM operations.
 ///
-/// This operation takes 6 cycles.
+/// This operation takes 4 cycles.
 pub fn u32gt(span: &mut SpanBuilder) -> Result<Option<CodeBlock>, AssemblyError> {
     // Reverse the numbers so we can get a gt check.
     span.push_op(Swap);
@@ -417,7 +433,7 @@ pub fn u32gt(span: &mut SpanBuilder) -> Result<Option<CodeBlock>, AssemblyError>
 
 /// Translates u32gte assembly instructions to VM operations.
 ///
-/// This operation takes 6 cycles.
+/// This operation takes 4 cycles.
 pub fn u32gte(span: &mut SpanBuilder) -> Result<Option<CodeBlock>, AssemblyError> {
     compute_lt(span);
 
@@ -457,11 +473,10 @@ pub fn u32max(span: &mut SpanBuilder) -> Result<Option<CodeBlock>, AssemblyError
 // ================================================================================================
 
 /// Inserts the VM operations to check if the second element is less than
-/// the top element. This takes 5 cycles.
+/// the top element. This takes 3 cycles.
 fn compute_lt(span: &mut SpanBuilder) {
     span.push_ops([
         U32sub, Swap, Drop, // Perform the operations
-        Eqz, Not, // Check the underflow flag
     ])
 }
 

assembly/src/ast/nodes/mod.rs

@@ -96,6 +96,8 @@ pub enum Instruction {
     U32Assert2WithError(ErrorCode),
     U32AssertW,
     U32AssertWWithError(ErrorCode),
+    U32AssertLt,
+    U32AssertLtImm(u32),
     U32Split,
     U32Cast,
     U32WrappingAdd,
@@ -354,6 +356,8 @@ impl fmt::Display for Instruction {
             Self::U32Assert2WithError(err_code) => write!(f, "u32assert2.err={err_code}"),
             Self::U32AssertW => write!(f, "u32assertw"),
             Self::U32AssertWWithError(err_code) => write!(f, "u32assertw.err={err_code}"),
+            Self::U32AssertLt => write!(f, "u32assert_lt"),
+            Self::U32AssertLtImm(value) => write!(f, "u32assert_lt.{value}"),
             Self::U32Split => write!(f, "u32split"),
             Self::U32Cast => write!(f, "u32cast"),
             Self::U32WrappingAdd => write!(f, "u32wrapping_add"),

assembly/src/ast/nodes/serde/deserialization.rs

@@ -113,6 +113,8 @@ impl Deserializable for Instruction {
             OpCode::U32Assert2WithError => Ok(Instruction::U32Assert2WithError(source.read_u32()?)),
             OpCode::U32AssertW => Ok(Instruction::U32AssertW),
             OpCode::U32AssertWWithError => Ok(Instruction::U32AssertWWithError(source.read_u32()?)),
+            OpCode::U32AssertLt => Ok(Instruction::U32AssertLt),
+            OpCode::U32AssertLtImm => Ok(Instruction::U32AssertLtImm(source.read_u32()?)),
             OpCode::U32Split => Ok(Instruction::U32Split),
             OpCode::U32Cast => Ok(Instruction::U32Cast),
             OpCode::U32WrappingAdd => Ok(Instruction::U32WrappingAdd),