Fix CBM example in README; align CBM wire format with schema

The README's `pred create CBM ... | pred solve` example was broken on two
fronts: the bound flag is `--bound-k` (not `--bound`), and the schema-driven
factory rejected the generated JSON because `ConsecutiveBlockMinimization`'s
deserialization required `num_rows`/`num_cols` fields that aren't part of
its declared schema (only `matrix` and `bound` are).

Drop the derived dimensions from the wire format entirely via
`serde(into = ConsecutiveBlockMinimizationDef)` so serialize and deserialize
both use the minimal `{matrix, bound}` form that matches `ProblemSchemaEntry`.
Replace the now-irrelevant inconsistent-dimensions test with one that pins
the minimal wire format and one that exercises ragged-matrix rejection.

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

Author: GiggleLiu

README.md

@@ -36,7 +36,7 @@ Try it out:
 pred show CBM
 
 # Create and solve a small CBM instance
-pred create CBM --matrix '[[true,false,true],[false,true,true]]' --bound 2 \
+pred create CBM --matrix '[[true,false,true],[false,true,true]]' --bound-k 2 \
   | pred solve - --solver brute-force
 ```
 

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]