Align CBM serialized form with declared schema (#1065)

* Align CBM serialized form with declared schema

`ConsecutiveBlockMinimization`'s `ProblemSchemaEntry::fields` declares
`matrix` and `bound`, but its serialized form also wrote `num_rows` and
`num_cols`, and its `try_from` rejected JSON that lacked them.  This made
the schema-driven `pred create` path fail with "missing field `num_rows`"
for any caller that built JSON from the declared schema fields.

`num_rows` and `num_cols` are fully derived from `matrix` (just
`matrix.len()` and `matrix[0].len()`), so they don't belong in the wire
format.  Switch to symmetric `serde(try_from / into = Def)` so both
serialize and deserialize round-trip through the minimal `{matrix, bound}`
form, and let `try_new` recompute the cached dimensions on the way in.
The cached fields stay on the in-memory struct for fast getter access.

Replace the now-unreachable inconsistent-dimensions test with one that
pins the minimal wire format and one that exercises ragged-matrix
rejection — the actual remaining input validation.

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

* fix: update CBM CLI rejection test for new wire format

The CI Test job for #1065 failed because cli_tests.rs:445 still asserted
the old "num_cols must match matrix column count" error. Under the new
serde definition, extra num_rows/num_cols fields in the JSON are silently
ignored (serde's default behavior for unknown fields when not using
deny_unknown_fields), so the previous JSON now deserializes successfully
and the CLI no longer rejects it.

Switch the test to exercise the actual remaining input validation —
ragged-matrix rejection — which is what `validate_matrix_dimensions`
guards against and what the in-tree unit test now also covers. Rename
the test accordingly.

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

---------

Co-authored-by: Claude Opus 4.7 <noreply@anthropic.com>

Author: GiggleLiu

problemreductions-cli/tests/cli_tests.rs

@@ -423,17 +423,15 @@ fn test_evaluate_sat() {
 }
 
 #[test]
-fn test_evaluate_consecutive_block_minimization_rejects_inconsistent_dimensions() {
+fn test_evaluate_consecutive_block_minimization_rejects_ragged_matrix() {
     let problem_json = r#"{
         "type": "ConsecutiveBlockMinimization",
         "data": {
-            "matrix": [[true]],
-            "num_rows": 1,
-            "num_cols": 2,
+            "matrix": [[true, false], [true]],
             "bound": 1
         }
     }"#;
-    let tmp = std::env::temp_dir().join("pred_test_eval_cbm_invalid_dims.json");
+    let tmp = std::env::temp_dir().join("pred_test_eval_cbm_ragged_matrix.json");
     std::fs::write(&tmp, problem_json).unwrap();
 
     let output = pred()
@@ -442,7 +440,7 @@ fn test_evaluate_consecutive_block_minimization_rejects_inconsistent_dimensions(
         .unwrap();
     assert!(!output.status.success());
     let stderr = String::from_utf8_lossy(&output.stderr);
-    assert!(stderr.contains("num_cols must match matrix column count"));
+    assert!(stderr.contains("same length"));
     assert!(!stderr.contains("panicked at"), "stderr: {stderr}");
     std::fs::remove_file(&tmp).ok();
 }

src/models/algebraic/consecutive_block_minimization.rs

@@ -58,7 +58,10 @@ inventory::submit! {
 /// }
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(try_from = "ConsecutiveBlockMinimizationDef")]
+#[serde(
+    try_from = "ConsecutiveBlockMinimizationDef",
+    into = "ConsecutiveBlockMinimizationDef"
+)]
 pub struct ConsecutiveBlockMinimization {
     /// The binary matrix A (m x n).
     matrix: Vec<Vec<bool>>,
@@ -184,32 +187,26 @@ crate::declare_variants! {
     default ConsecutiveBlockMinimization => "factorial(num_cols) * num_rows * num_cols",
 }
 
-#[derive(Debug, Clone, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 struct ConsecutiveBlockMinimizationDef {
     matrix: Vec<Vec<bool>>,
-    num_rows: usize,
-    num_cols: usize,
     bound: i64,
 }
 
 impl TryFrom<ConsecutiveBlockMinimizationDef> for ConsecutiveBlockMinimization {
     type Error = String;
 
     fn try_from(value: ConsecutiveBlockMinimizationDef) -> Result<Self, Self::Error> {
-        let problem = Self::try_new(value.matrix, value.bound)?;
-        if value.num_rows != problem.num_rows {
-            return Err(format!(
-                "num_rows must match matrix row count ({})",
-                problem.num_rows
-            ));
-        }
-        if value.num_cols != problem.num_cols {
-            return Err(format!(
-                "num_cols must match matrix column count ({})",
-                problem.num_cols
-            ));
+        Self::try_new(value.matrix, value.bound)
+    }
+}
+
+impl From<ConsecutiveBlockMinimization> for ConsecutiveBlockMinimizationDef {
+    fn from(value: ConsecutiveBlockMinimization) -> Self {
+        Self {
+            matrix: value.matrix,
+            bound: value.bound,
         }
-        Ok(problem)
     }
 }
 

src/unit_tests/models/algebraic/consecutive_block_minimization.rs

@@ -91,10 +91,20 @@ fn test_consecutive_block_minimization_serialization() {
 }
 
 #[test]
-fn test_consecutive_block_minimization_deserialization_rejects_inconsistent_dimensions() {
-    let json = r#"{"matrix":[[true]],"num_rows":1,"num_cols":2,"bound":1}"#;
+fn test_consecutive_block_minimization_serialization_omits_derived_fields() {
+    let problem = ConsecutiveBlockMinimization::new(vec![vec![true, false], vec![false, true]], 2);
+    let value: serde_json::Value = serde_json::to_value(&problem).unwrap();
+    let obj = value.as_object().unwrap();
+    assert_eq!(obj.len(), 2);
+    assert!(obj.contains_key("matrix"));
+    assert!(obj.contains_key("bound"));
+}
+
+#[test]
+fn test_consecutive_block_minimization_deserialization_rejects_ragged_matrix() {
+    let json = r#"{"matrix":[[true,false],[true]],"bound":1}"#;
     let err = serde_json::from_str::<ConsecutiveBlockMinimization>(json).unwrap_err();
-    assert!(err.to_string().contains("num_cols"));
+    assert!(err.to_string().contains("same length"));
 }
 
 #[test]