fn less_than_bb_modulus(&mut self, num_bits: Array<C, Var<C::N>>) {
        let one: Var<_> = self.eval(C::N::one());
        let zero: Var<_> = self.eval(C::N::zero());

        let mut most_sig_4_bits = one;
        for i in (NUM_BITS - 4)..NUM_BITS {
            let bit = self.get(&num_bits, i);
            most_sig_4_bits = self.eval(bit * most_sig_4_bits);
        }

        let mut sum_least_sig_bits = zero;
        for i in 0..(NUM_BITS - 4) {
            let bit = self.get(&num_bits, i);
            sum_least_sig_bits = self.eval(bit + sum_least_sig_bits);
        }

        // If the most significant 4 bits are all 1, then check the sum of the least significant
        // bits, else return zero.
        let check: Var<_> =
            self.eval(most_sig_4_bits * sum_least_sig_bits + (one - most_sig_4_bits) * zero);
        self.assert_var_eq(check, zero);
    }
Checks that the LE bit decomposition of a number is less than the babybear modulus.

SAFETY: This function assumes that the num_bits values are already verified to be boolean.

The babybear modulus in LE bits is: 100_000_000_000_000_000_000_000_000_111_1.
To check that the num_bits array is less than that value, we first check if the most
significant bits are all 1.  If it is, then we assert that the other bits are all 0.
crates/recursion/compiler/src/ir/bits.rs