[zzylol]

Why

UnivMon::init_univmon panics on a shape it cannot hash independently (#220), and both ASAPv1 wire doors refuse more than MATRIX_MAX_ROWS (20) rows. A caller that sizes a pyramid from configuration cannot ask whether a shape is valid without catching a panic, so ASAPPlanner restated the rules twice: its executor's check_dimensions (positive dimensions, 20 rows, 19 layers, rows * (ceil_log2(cols) + 1) <= 128) and its accuracy model's hash_independent, which missed the 20-row bound. And the constructor itself still built a 21-row pyramid that neither wire door would carry.

What

• UnivMon::check_shape(heap_size, sketch_row, sketch_col, layer_size) -> Result<(), String>: accepts exactly the shapes init_univmon builds.
• init_univmon panics exactly when check_shape fails. That adds one case: more than MATRIX_MAX_ROWS rows, which the wire already refused. Every shape that serialized before still builds and hashes as before.

Builds on #220 (merged).

How

check_shape composes the wire's own checks (check_univmon_dimensions, check_layer_size, l2hh_wire::check_dimensions, which carries MATRIX_MAX_ROWS and the 128-bit hash budget) plus a usize overflow check on the counter count. init_univmon's five assert!s become one call. So the constructor and the wire cannot drift.

Key code interfaces added / modified

src/sketch_framework/univmon.rs

impl UnivMon {
    /// Checks a pyramid shape without building it: every dimension positive,
    /// at most MAX_LAYER_SIZE layers, at most MATRIX_MAX_ROWS rows (what the
    /// ASAPv1 wire carries), rows whose column and sign bits fit one 128-bit
    /// key hash, and a counter count that fits usize. Err names the broken
    /// rule; it is bad input. Used before a caller accepts a configuration.
    pub fn check_shape(heap_size: usize, sketch_row: usize, sketch_col: usize, layer_size: usize) -> Result<(), String>;   // new

    /// Creates a pyramid. Panics when `check_shape` fails.
    pub fn init_univmon(heap_size: usize, sketch_row: usize, sketch_col: usize, layer_size: usize) -> Self;   // was: panicked on its own asserts and built > MATRIX_MAX_ROWS rows
}

Usage, end to end (checked by a scratch test at the head commit):

use asap_sketchlib::UnivMon;

// 1. A planner sized an L2 norm query as a UnivMon with a 64-key heap, 5 x 2048 rows and
//    12 layers. Before accepting the plan the executor asks the library. `ok` is Ok(()).
let ok = UnivMon::check_shape(64, 5, 2048, 12);
// `too_deep` is Err("CountL2HH rows 21 exceeds MATRIX_MAX_ROWS 20"): the plan is rejected, not
// built into a state the wire refuses.
let too_deep = UnivMon::check_shape(64, 21, 2, 1);
// `too_wide` is Err("CountL2HH rows=11, cols=2048 needs 132 hash bits (11 column bits + 1 sign
// bit per row), past the 128 the key hash carries").
let too_wide = UnivMon::check_shape(64, 11, 2048, 1);

// 2. An accepted shape builds; `sketch` is the population's state, fed at ingestion and read
//    by the query (12 layers).
let sketch = UnivMon::init_univmon(64, 5, 2048, 12);

Before this PR

Callers copied the rules or caught panics; init_univmon(4, 21, 16, 3) built a pyramid whose serialize_to_bytes then failed.

After this PR

One fallible call answers whether a shape is valid; init_univmon refuses the 21-row pyramid up front. ASAPPlanner's companion PR deletes its check_dimensions and points its accuracy model at check_shape.

Verification

• New check_shape_accepts_exactly_what_init_univmon_builds: eleven shapes (the 10 x 2048 / 11 x 2048 hash-bit boundary, MAX_LAYER_SIZE and one past, each zero dimension, 20 rows and 21). It failed first on the 21-row shape, which init_univmon built.
• univmon_rejects_too_many_layer_rows now checks that construction refuses 21 rows (it used to build one to check the encoder refused it); the decoder half is unchanged. univmon_refuses_constructing_past_the_shift_bound expects the wire check's message ("exceeds MAX_LAYER_SIZE").
• cargo fmt --all -- --check; clippy with -D warnings for --all-features, default features, experimental and octo-runtime; cargo test --all-features --locked (every target) passes.

Limitations

The error is a String, like the wire checks it reuses. UnivMonPyramid (univmon_optimized) keeps its own asserts; it has no planner caller.