Update the B-Z test comments

Author: cuviper

tests/biguint.rs

@@ -924,18 +924,16 @@ fn test_div_rem_big_multiple() {
 
 #[test]
 fn test_div_rem_burnikel_ziegler_u1_equals_d() {
-    // Construct u and d such that the B-Z entry point sees u1 == d.
+    // Construct u and d such that div_blocks' most-significant block equals d.
     //
     // d has 65 u64-digits (130 u32-digits) with MSB set, ensuring:
     //   - d.len() > 64 (enters B-Z)
-    //   - no normalization shift (MSB already set)
+    //   - level = next_power_of_two(65) = 128
     //
-    // u = d << 8192 + 42, so u's high part (split at `level` digits) is exactly d.
-    //   For u64: u.len()=193, level=128, split gives u1=d
-    //   For u32: u.len()=386, level=256, split gives u1=d
-    //
-    // The entry point originally had `if &u1 > d` (should be >=), so the else branch was
-    // taken with u1==d, violating div_two_digit_by_one's precondition ah < b.
+    // The normalization shift pads d to fill the full 128 digits. Then u = d << 8192 + 42 is also
+    // shifted, so the most-significant block of u (chunked at `level` digits) equals d exactly.
+    // So div_blocks must not peel it off as the initial remainder (since it's not strictly less
+    // than d), instead starting with r = 0.
     let d = (BigUint::one() << 4159usize) + BigUint::one();
     let remainder = BigUint::from(42u32);
     let u = (&d << 8192usize) + &remainder;
@@ -951,12 +949,11 @@ fn test_div_rem_burnikel_ziegler_a1_equals_b1() {
     // This triggered a bug for the missing a1 >= b1 guard in div_three_halves_by_two
     // (Algorithm 2, step 3b of the Burnikel-Ziegler paper).
     //
-    // d has 65 u64-digits (130 u32-digits). In div_two_digit_by_one, the normalization
-    // shift pads d to fill `level` digits. After div_two_digit_by_one_normalized splits
-    // both ah and the shifted d at the half-level, the second div_three_halves_by_two call
-    // receives a remainder whose upper half equals b1 (the upper half of the shifted d).
-    // It then called div_two_digit_by_one(a1, a2, b1, level) with a1 == b1, violating the
-    // a1 < b1 precondition.
+    // d has 65 u64-digits (130 u32-digits). The top-level normalization shift pads d to fill
+    // `level` digits, and div_two_digit_by_one splits both ah and the shifted d at the half-level.
+    // Then the second div_three_halves_by_two call receives a remainder whose upper half equals b1
+    // (the upper half of the shifted d). It then called div_two_digit_by_one(a1, a2, b1, level)
+    // with a1 == b1, violating the a1 < b1 precondition.
     //
     // The quotient ((1 << 4096) - 1) is chosen so the remainder is d - 1, which shares
     // the same upper half as d after normalization.