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>

Author: GiggleLiu

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]