gauntlet: cycle 3 fixes for tq-l2-norm

Apply 3 fixes from the cycle-3 phase-3 gauntlet review of the cycle-2
fix-commit (8c02fe56d).

- Cover `-0.0` in the negative-stored-norm guard (l2_norm.rs): cycle-2
  used `*n < T::zero()` which is `false` for `-0.0` per IEEE 754, so a
  hand-constructed `-0.0` stored norm slipped through and the kernel
  returned `-0.0` while canonical computed `sqrt(sum_sq) == +0.0`.
  Switch to `n.is_sign_negative()`, which covers both strictly-negative
  values and `-0.0`. The comment now documents the IEEE 754 subtlety
  and the cache-warm `O(rows)` cost of the scan.

- Add `l2_norm_over_tq_decode_with_negative_stored_norm_falls_back`
  (kernels.rs), parameterized over `-5.0` and `-0.0`, that hand-builds
  a TurboQuant array with a sign-negative stored norm and asserts the
  result is non-negative and finite (proving the kernel fell back to
  the canonical path, which always returns `|stored_norm|`).

- Add `l2_norm_over_tq_decode_rejects_codes_validity_narrower_than_struct`
  (kernels.rs) that hand-builds a TurboQuant array whose `codes` child
  has row validity narrower than the outer struct's, mirroring the
  existing canonical-path
  `decode_rejects_child_masks_that_disagree_with_struct_validity` test.
  Asserts `L2Norm(TQDecode(_))` errors via `parse_storage_norms_only`'s
  validation, pinning the fast/slow-path validation parity that the
  cycle-1 fix-commit added.

Signed-off-by: Connor Tsui <connor.tsui20@gmail.com>

Author: connortsui20

vortex-turboquant/src/scalar_fns/compute/l2_norm.rs

@@ -4,7 +4,6 @@
 //! `L2Norm` execute-parent kernel that intercepts `L2Norm(TQDecode(tq))` and returns the
 //! stored per-row norms directly instead of decoding and recomputing.
 
-use num_traits::Zero;
 use vortex_array::ArrayRef;
 use vortex_array::ExecutionCtx;
 use vortex_array::IntoArray;
@@ -64,14 +63,25 @@ fn l2_norm_tq_decode_execute_parent(
     let parsed = parse_storage_norms_only(tq_array, ctx)?;
 
     // Fall back to the canonical `L2Norm` path on the (adversarial) case where any stored
-    // norm is strictly negative. Encode always produces non-negative norms (via `L2Norm`,
-    // which returns `sqrt(sum_sq)`), but a hand-constructed TurboQuant storage could carry
-    // arbitrary values in the `norms` child. Returning the stored bits verbatim would then
-    // violate `L2Norm`'s always-non-negative output invariant. The canonical path runs the
-    // in-flight decode rescaling and reapplies the stored norm, so its `L2Norm` output is
-    // `|stored_norm|` for every row by construction.
+    // norm has its sign bit set. Encode always produces non-negative norms (via `L2Norm`,
+    // which returns `sqrt(sum_sq)` and never yields `-0.0`), but a hand-constructed
+    // TurboQuant storage could carry arbitrary values in the `norms` child. Returning the
+    // stored bits verbatim would then violate `L2Norm`'s always-non-negative output
+    // invariant. The canonical path runs the in-flight decode rescaling and reapplies the
+    // stored norm, so its `L2Norm` output is `|stored_norm|` for every row by construction.
+    //
+    // Using `is_sign_negative` rather than `< T::zero()` is load-bearing: `-0.0 < 0.0` is
+    // `false` per IEEE 754, so a literal comparison would miss a stored `-0.0` while the
+    // canonical path would still collapse it to `+0.0` via `sqrt(sum_sq)`.
+    //
+    // The scan is `O(rows)` over a buffer the just-completed `parse_storage_norms_only`
+    // materialized, so it does not move the kernel out of its constant-time-per-row regime.
     let has_negative_norm = match_each_float_ptype!(parsed.norms.ptype(), |T| {
-        parsed.norms.as_slice::<T>().iter().any(|n| *n < T::zero())
+        parsed
+            .norms
+            .as_slice::<T>()
+            .iter()
+            .any(|n| n.is_sign_negative())
     });
     if has_negative_norm {
         return Ok(None);

vortex-turboquant/src/tests/kernels.rs

@@ -269,3 +269,105 @@ fn l2_norm_over_tq_decode_matches_canonical(#[case] dim: u32) -> VortexResult<()
     }
     Ok(())
 }
+
+/// Adversarial: a hand-constructed TurboQuant storage with a `-5.0` or `-0.0` stored norm
+/// makes the fast path fall back to the canonical `L2Norm(execute(TQDecode))` path so that
+/// the result preserves `L2Norm`'s always-non-negative output invariant. The kernel scans
+/// the parsed `norms` once and triggers fallback via `is_sign_negative`, which covers both
+/// strictly-negative values and `-0.0` (where the literal `< 0` comparison would fail per
+/// IEEE 754).
+#[rstest]
+#[case::strict_negative(-5.0_f32)]
+#[case::negative_zero(-0.0_f32)]
+fn l2_norm_over_tq_decode_with_negative_stored_norm_falls_back(
+    #[case] stored: f32,
+) -> VortexResult<()> {
+    let session = test_session();
+    let mut ctx = session.create_execution_ctx();
+    let metadata = TurboQuantMetadata {
+        element_ptype: PType::F32,
+        dimensions: DIM,
+        bit_width: 1,
+        seed: 42,
+        num_rounds: 3,
+    };
+
+    let norms =
+        PrimitiveArray::new::<f32>(Buffer::copy_from([stored]), Validity::NonNullable).into_array();
+    let codes = PrimitiveArray::new::<u8>(vec![0u8; DIM as usize], Validity::NonNullable);
+    let codes = FixedSizeListArray::try_new(codes.into_array(), DIM, Validity::NonNullable, 1)?
+        .into_array();
+    let storage = StructArray::try_new(
+        FieldNames::from(["norms", "codes"]),
+        vec![norms, codes],
+        1,
+        Validity::NonNullable,
+    )?;
+    let tq = ExtensionArray::try_new_from_vtable(TurboQuant, metadata, storage.into_array())?
+        .into_array();
+
+    let decoded = TQDecode::try_new_array(tq)?.into_array();
+    let result: PrimitiveArray = L2Norm::try_new_array(decoded, 1)?
+        .into_array()
+        .execute(&mut ctx)?;
+
+    // Whatever path runs, the result is an `L2Norm` output and must be non-negative; in
+    // particular the kernel must NOT return the stored sign-negative value verbatim. The
+    // exact magnitude depends on which centroid the all-zero codes decode to; we only
+    // assert the sign and finiteness, which is what `L2Norm`'s contract pins.
+    assert_eq!(result.as_slice::<f32>().len(), 1);
+    let value = result.as_slice::<f32>()[0];
+    assert!(
+        value.is_finite() && !value.is_sign_negative(),
+        "L2Norm result must be non-negative and finite (got {value})"
+    );
+    Ok(())
+}
+
+/// Adversarial: a hand-constructed TurboQuant storage whose `codes` child has row validity
+/// narrower than the outer struct's must fail the fast path the same way it fails the
+/// canonical decode path (see `malformed::decode_rejects_child_masks_that_disagree_with_struct_validity`).
+/// `parse_storage_norms_only` executes the `codes` FSL wrapper specifically to enforce this
+/// invariant.
+#[test]
+fn l2_norm_over_tq_decode_rejects_codes_validity_narrower_than_struct() -> VortexResult<()> {
+    let session = test_session();
+    let mut ctx = session.create_execution_ctx();
+    let metadata = TurboQuantMetadata {
+        element_ptype: PType::F32,
+        dimensions: DIM,
+        bit_width: 1,
+        seed: 42,
+        num_rounds: 3,
+    };
+
+    let norms =
+        PrimitiveArray::new::<f32>(Buffer::copy_from([1.0f32, 1.0, 1.0]), Validity::NonNullable)
+            .into_array();
+    let codes = PrimitiveArray::new::<u8>(vec![0u8; 3 * DIM as usize], Validity::NonNullable);
+    let codes = FixedSizeListArray::try_new(
+        codes.into_array(),
+        DIM,
+        Validity::from_iter([true, false, true]),
+        3,
+    )?
+    .into_array();
+    let storage = StructArray::try_new(
+        FieldNames::from(["norms", "codes"]),
+        vec![norms, codes],
+        3,
+        Validity::NonNullable,
+    )?;
+    let tq = ExtensionArray::try_new_from_vtable(TurboQuant, metadata, storage.into_array())?
+        .into_array();
+
+    let decoded = TQDecode::try_new_array(tq)?.into_array();
+    let result: VortexResult<PrimitiveArray> = L2Norm::try_new_array(decoded, 3)?
+        .into_array()
+        .execute(&mut ctx);
+    assert!(
+        result.is_err(),
+        "kernel must reject codes-validity narrower than struct-validity"
+    );
+    Ok(())
+}