@@ -87,9 +87,8 @@ fn encoded(shape: Shape) -> EliasFanoArray {
     elias_fano_encode(array.as_ref().as_::<Primitive>(), &mut ctx).unwrap()
 }
 
-/// Probe count held fixed across shapes, so the reported figure is comparable. Each probe runs a
-/// whole `execute_scalar`, so this is a quarter of the codec benchmark's count to stay well inside
-/// the per-iteration budget.
+/// Probes per iteration, fixed across shapes so the figures compare. Each runs a whole
+/// `execute_scalar`, hence a quarter of the codec benchmark's count.
 const PROBES: usize = 1024;
 
 fn random_indices() -> Vec<usize> {
 
@@ -610,11 +610,9 @@ fn validate_parts(
         "Elias-Fano low-bits child must be {LOWER_DTYPE}, got {}",
         lower.dtype()
     );
-    // A bit-packed slot's global width is metadata, so this is free to check and is the only part
-    // of the low bits checkable at all. Narrower is legal — a rewrite may repack tighter. Wider is
-    // not: the reader ORs the low bits in under `lower_width`, so anything above bleeds into the
-    // high part. Blocked widths live in a child array rather than metadata, so a blocked slot is
-    // accepted like any other integer child.
+    // A globally packed slot's width is metadata, so it is free to check. Narrower is legal, since
+    // a rewrite may repack tighter; wider could hold low parts the reader would mask off. Blocked
+    // widths live in a child array, so a blocked slot is accepted like any other integer child.
     if let Some(packed) = lower.as_opt::<BitPacked>()
         && let BitWidthsView::Global(bit_width) = packed.bit_widths()
     {
 
@@ -137,9 +137,8 @@ pub(crate) fn elias_fano_decompress(
     let start = ef::position_of_rank(bits, samples1, first_rank).map_err(malformed)?;
     let end =
         ef::position_of_rank(bits, samples1, first_rank + len as u64 - 1).map_err(malformed)? + 1;
-    // Validation checks the sample table's ranges and order, not its agreement with the upper
-    // array, so a corrupt table can place the last rank's bit before the first's. Raise rather than
-    // let `window_words` assert on the reversed window.
+    // Validation does not check samples against the upper array, so a corrupt table can put the
+    // last rank before the first. Raise instead of letting `window_words` assert.
     vortex_ensure!(
         start < end,
         "Elias-Fano sample table disagrees with the upper array"
 
@@ -670,17 +670,15 @@ fn test_rejects_corrupt_samples(#[case] poison: u64) -> VortexResult<()> {
     Ok(())
 }
 
-/// A one-sample that is in range and in order passes validation even when it points at the wrong
-/// bit, since samples are not checked against the upper array. Decoding a slice across it then
-/// finds its last rank's bit before its first's, which must raise rather than reach the assert in
-/// `window_words`.
+/// A misplaced one-sample passes validation, since samples are not checked against the upper
+/// array. Decoding a slice across it must raise, not panic.
 #[test]
 fn test_decompress_raises_on_misplaced_sample() -> VortexResult<()> {
     let encoded = encode(&sorted_values(5000, 1 << 30, 0xDEFACED))?;
     let mut ctx = SESSION.create_execution_ctx();
 
-    // The first one-sample stands for rank 256. Its lowest legal position is 257, well below where
-    // rank 256 really sits in a sparse sequence, so a select for 256 now lands on an earlier bit.
+    // The first one-sample stands for rank 256; 257 is its lowest legal position, well before
+    // rank 256's real bit.
     let seam = usize::try_from(encoded.num_samples0())? * size_of::<u64>();
     let mut poisoned = encoded.samples_buffer().clone().into_mut();
     poisoned[seam..seam + size_of::<u64>()].copy_from_slice(&257u64.to_le_bytes());