fix(notation): add spaces around $\times$ in conv lst-cap

Pre-push hook 'Book: check math (\times spacing)' flagged the
'Logical Convolution Computation' lst-cap (vol1/nn_architectures L1793)
for missing spaces around $\times$. The lst-cap was reverted to bare-prose
form earlier (commit d551574) because the canonical math-mode form
$O(\text{batch} \times \text{output\_channels} \times ...)$ broke LaTeX
inside lst-cap=. Bare-prose form needs explicit spacing.

Was: O(batch$\times$height$\times$width$\times$output_channels$\times$...)
Now: O(batch $\times$ height $\times$ width $\times$ output_channels $\times$ ...)

Author: profvjreddi

book/quarto/contents/vol1/nn_architectures/nn_architectures.qmd

@@ -1646,13 +1646,13 @@ The preceding architectural properties make CNNs highly amenable to systems-leve
 
 ::: {tbl-colwidths="[17,30,53]"}
 
-| **Property**    | **Value**                                                            | **System Implication**                                                                               |
-|:----------------|:---------------------------------------------------------------------|:-----------------------------------------------------------------------------------------------------|
-| **Parameters**  | `{python} LighthouseSpecs.resnet_params_m_str` million               | `{python} LighthouseSpecs.resnet_fp32_mb_str` MB model size at FP32; fits comfortably in GPU memory. |
-| **FLOPs/Image** | `{python} LighthouseSpecs.resnet_gflops_str` GFLOPs $(224{\times}224)$ | Dominated by $3{\times}3$ convolutions (~90 percent of compute).                                       |
-| **Constraint**  | Compute Bound                                                        | Limited by raw FLOPs, not memory bandwidth.                                                          |
-| **Bottleneck**  | FP Throughput                                                        | Benefits maximally from specialized Matrix Units (Tensor Cores).                                     |
-| **Profile**     | High Arithmetic Intensity                                            | High ratio of math-to-memory operations (~100 FLOPs/byte).                                           |
+| **Property**    | **Value**                                                              | **System Implication**                                                                               |
+|:----------------|:-----------------------------------------------------------------------|:-----------------------------------------------------------------------------------------------------|
+| **Parameters**  | `{python} LighthouseSpecs.resnet_params_m_str` million                 | `{python} LighthouseSpecs.resnet_fp32_mb_str` MB model size at FP32; fits comfortably in GPU memory. |
+| **FLOPs/Image** | `{python} LighthouseSpecs.resnet_gflops_str` GFLOPs $(224{\times}224)$ | Dominated by $3{\times}3$ convolutions (~90 percent of compute).                                     |
+| **Constraint**  | Compute Bound                                                          | Limited by raw FLOPs, not memory bandwidth.                                                          |
+| **Bottleneck**  | FP Throughput                                                          | Benefits maximally from specialized Matrix Units (Tensor Cores).                                     |
+| **Profile**     | High Arithmetic Intensity                                              | High ratio of math-to-memory operations (~100 FLOPs/byte).                                           |
 
 :::
 :::
@@ -1790,7 +1790,7 @@ The bridge between the logical model and physical execution becomes critical for
 
 @lst-conv_layer_compute reveals the logical computational pattern: seven nested loops that process each spatial position. While functionally correct, this naive implementation is rarely used in practice due to poor memory locality. Instead, the **im2col** approach trades memory (duplicating overlapping input pixels) for computational regularity, converting the messy nested loops into a streamlined matrix multiplication that saturates hardware FP units.
 
-::: {#lst-conv_layer_compute lst-cap="**Logical Convolution Computation**: Seven nested loops expose O(batch$\times$height$\times$width$\times$output_channels$\times$kernel_h$\times$kernel_w$\times$input_channels) complexity. While logically sound, this pattern is inefficient on hardware; production systems transform this into tiled matrix multiplications."}
+::: {#lst-conv_layer_compute lst-cap="**Logical Convolution Computation**: Seven nested loops expose O(batch $\times$ height $\times$ width $\times$ output_channels $\times$ kernel_h $\times$ kernel_w $\times$ input_channels) complexity. While logically sound, this pattern is inefficient on hardware; production systems transform this into tiled matrix multiplications."}
 
 ```{.python}
 def conv_layer_compute(input, kernel, bias):