fix(latex): LaTeX-export audit findings (F5/F13/F14) (#75)

* fix(latex): LaTeX-export audit findings F5/F13/F14

F5 (latex_formatting.py) — uncertainty rounding carry-over understated the
displayed uncertainty 10x when a magnitude>=1 value rounded up to the next power
of ten at the requested sig figs (9.6@1sf rendered as "1", 99.6@2sf as "10").
The carry branch used unc_int//10 with decimal_places-1; use unc_int=10**target
at the same decimal place so 9.6->10, 0.96->1.0, 99.6->100.

F13 (latex_tables_statistics_matrix.py) — the covariance/correlation matrix table
hardcoded d{12} / S[table-format=1.16] instead of computing per-column specs from
cell magnitudes, so large/small/exponent entries overflowed the fixed format.
Compute each column's spec via calculate_dcolumn_format_for_column /
_siunitx_column_spec like every other table family.

F14 (latex_tables_error_propagation.py) — the user-supplied caption went into
\caption{...} unescaped, so LaTeX specials (_ % & # $) broke compilation. Escape
it via _escape_latex_text (the fallback stays verbatim, it is already LaTeX).

TDD: carry-over cases (9.6/99.6/0.96) + non-carry regression guard; matrix
siunitx test updated to assert a computed S[table-format=...] spec.

* test(latex): assert concrete per-column siunitx specs in statistics-matrix

Review follow-up on the F13 per-column siunitx/dcolumn fix. The test only checked
that some "S[table-format=" substring existed, which would miss a regression in
the per-column formatter (e.g. reverting to a single hardcoded spec). Assert the
concrete list of per-column specs produced for this payload instead.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

---------

Co-authored-by: fanghao <fanghaoaa@gmail.com>
Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>

Author: 3 people

datalab_latex/latex_formatting.py

@@ -348,10 +348,18 @@ def _uncertainty_decimal_places(unc: mp.mpf, target_digits: int) -> tuple[int, s
     decimal_places = max(0, target_digits - 1 - order)
     scale = mp.power(10, decimal_places)
     unc_int = int(mp.nint(s_abs * scale))
-    # Handle rare rounding causing carry into extra digit
+    # Rounding can carry into an extra digit (e.g. 9.6 @ 1 sig fig -> nint(9.6)=10).
+    # The rounded value then has target_digits+1 digits; drop the least-significant
+    # one so it keeps exactly target_digits sig figs at one lower decimal place:
+    # unc_int becomes 10**(target_digits-1) (10, 100, ...) — NOT unc_int/10, which
+    # would understate the magnitude by 10x (audit F5).
     if unc_int >= 10**target_digits:
-        unc_int = int(mp.nint(s_abs * scale / 10))
-        decimal_places = max(0, decimal_places - 1)
+        # Rounding carried into an extra digit (9.6@1sf -> nint=10, 99.6@2sf ->
+        # nint=100). The correct integer is 10**target_digits at the SAME decimal
+        # place: its real value is int(unc_int) * 10**-decimal_places, i.e.
+        # 9.6->10.0, 0.96->1.0, 99.6->100.0. The old code used unc_int//10 and
+        # decremented decimal_places, understating the uncertainty 10x (audit F5).
+        unc_int = 10**target_digits
     return decimal_places, str(unc_int)
 
 

datalab_latex/latex_tables_error_propagation.py

@@ -287,7 +287,10 @@ def generate_error_propagation_table(
                 "\\begin{table}[!ht]",
                 "\t\\centering",
                 "\t\\caption{{{0}}}\\label{{tab:error_propagation_{1}}}".format(
-                    caption
+                    # Escape the user-supplied caption so LaTeX specials
+                    # (_ % & # $) don't break compilation (audit F14); the
+                    # fallback is already-formatted LaTeX, so leave it verbatim.
+                    _escape_latex_text(caption)
                     if caption
                     else "Error propagation results using formula: $" + format_latex_formula(formula_str) + "$",
                     block_index,

datalab_latex/latex_tables_statistics_matrix.py

@@ -4,6 +4,7 @@
 from pathlib import Path
 from typing import Any
 
+from .latex_formatting import _siunitx_column_spec, calculate_dcolumn_format_for_column
 from .latex_tables_common import (
     _build_standalone_preamble,
     _estimate_page_geometry,
@@ -68,8 +69,26 @@ def _matrix_table_block(
     use_dcolumn: bool,
     unit: str = "",
 ) -> list[str]:
-    numeric_spec = "d{12}" if use_dcolumn else "S[table-format=1.16]"
-    column_spec = " ".join(["l", *(numeric_spec for _ in columns)])
+    # Compute each numeric column's spec from its actual cell magnitudes rather
+    # than hardcoding d{12} / S[table-format=1.16]; a large/small/exponent value
+    # otherwise overflows the fixed format and mis-renders or fails to compile
+    # (audit F13). Cells for display column j are values[i][j] across rows i.
+    values = block["values"]
+
+    def _column_cells(col_index: int) -> list[str]:
+        return [
+            "" if (col_index >= len(row) or row[col_index] is None) else str(row[col_index])
+            for row in values
+        ]
+
+    per_column_specs: list[str] = []
+    for col_index in range(len(columns)):
+        cells = _column_cells(col_index)
+        if use_dcolumn:
+            per_column_specs.append(calculate_dcolumn_format_for_column(cells, "statistics_matrix"))
+        else:
+            per_column_specs.append(_siunitx_column_spec(cells))
+    column_spec = " ".join(["l", *per_column_specs])
     lines = [
         f"\\subsection*{{{latex_escape(kind.capitalize())}}}",
         f"\\noindent Unit: \\texttt{{{latex_escape(unit)}}}" if unit else "",
@@ -83,7 +102,6 @@ def _matrix_table_block(
         "\\midrule",
     ]
     lines = [line for line in lines if line]
-    values = block["values"]
     for row_column, row in zip(columns, values):
         cells = [_numeric_cell(cell) for cell in row]
         lines.append(" & ".join([latex_escape(row_column)] + cells) + r" \\")

tests/test_datalab_core_statistics_matrix.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import re
 from copy import deepcopy
 from pathlib import Path
 
@@ -235,7 +236,13 @@ def test_statistics_matrix_latex_can_use_siunitx_columns() -> None:
     tex = generate_statistics_matrix_latex(payload, use_dcolumn=False, latex_group_size=0)
 
     assert "\\usepackage{dcolumn}" not in tex
-    assert "S[table-format=1.16]" in tex
+    # Column spec is now computed per-column from the actual cell magnitudes
+    # (audit F13). Assert the concrete specs, not just that some S column
+    # exists, so a regression in the per-column formatter is caught: this 3x2
+    # payload of small values yields one S[table-format=1.31] spec per numeric
+    # cell column (integer part width 1, fractional width from the precision).
+    specs = re.findall(r"S\[table-format=[^\]]*\]", tex)
+    assert specs == ["S[table-format=1.31]"] * 4
 
 
 def test_statistics_matrix_latex_handles_pairwise_payload_summary() -> None:

tests/test_uncertainty_rounding_carry.py

@@ -0,0 +1,40 @@
+"""Uncertainty rounding carry-over (audit finding F5).
+
+When a magnitude>=1 uncertainty rounds UP to the next power of ten at the
+requested significant digits, the carry handling must keep the magnitude
+(e.g. 9.6 @ 1 sig fig -> "10", not "1"), not shrink it 10x.
+"""
+
+from __future__ import annotations
+
+from mpmath import mp
+
+from datalab_latex.latex_formatting import _uncertainty_decimal_places
+
+
+def test_carry_to_next_power_of_ten_keeps_magnitude_one_sig_fig():
+    # 9.6 to 1 significant digit rounds to 10, not 1.
+    decimal_places, unc_str = _uncertainty_decimal_places(mp.mpf("9.6"), 1)
+    assert (decimal_places, unc_str) == (0, "10")
+
+
+def test_carry_to_next_power_of_ten_keeps_magnitude_two_sig_figs():
+    # 99.6 to 2 significant digits rounds to 100, not 10.
+    decimal_places, unc_str = _uncertainty_decimal_places(mp.mpf("99.6"), 2)
+    assert (decimal_places, unc_str) == (0, "100")
+
+
+def test_non_carry_cases_unchanged():
+    # Regression guard: values that do NOT carry stay exactly as before.
+    assert _uncertainty_decimal_places(mp.mpf("9.6"), 2) == (1, "96")
+    assert _uncertainty_decimal_places(mp.mpf("1.23"), 1) == (0, "1")
+    assert _uncertainty_decimal_places(mp.mpf("0.045"), 1) == (2, "4")
+
+
+def test_carry_with_fractional_uncertainty_keeps_magnitude():
+    # 0.96 to 1 sig fig carries to 1.0: unc_int "10" at decimal_places 1
+    # (real value = 10 * 10**-1 = 1.0), NOT "1" at dp 1 (= 0.1, 10x too small).
+    decimal_places, unc_str = _uncertainty_decimal_places(mp.mpf("0.96"), 1)
+    assert unc_str == "10"
+    assert decimal_places == 1
+    assert int(unc_str) * mp.power(10, -decimal_places) == mp.mpf("1")