fix: size_field_names returns source's own fields, not target's

size_field_names() was returning output_size field names from the first
matching reduction entry, which are the TARGET problem's fields when
the queried problem is a source. Now correctly extracts input variable
names when the problem is a source, and collects from all entries for
completeness.

Also tightens CLI inspect test to assert actual field names, and adds
a cross-check test verifying all overhead variables are valid source
size fields.

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

Author: GiggleLiu

problemreductions-cli/tests/cli_tests.rs

@@ -2093,7 +2093,22 @@ fn test_inspect_json_output() {
     let json: serde_json::Value = serde_json::from_str(&content).unwrap();
     assert_eq!(json["kind"], "problem");
     assert_eq!(json["type"], "MaximumIndependentSet");
-    assert!(json["size_fields"].is_array());
+    let size_fields: Vec<&str> = json["size_fields"]
+        .as_array()
+        .expect("size_fields should be an array")
+        .iter()
+        .map(|v| v.as_str().unwrap())
+        .collect();
+    assert!(
+        size_fields.contains(&"num_vertices"),
+        "MIS size_fields should contain num_vertices, got: {:?}",
+        size_fields
+    );
+    assert!(
+        size_fields.contains(&"num_edges"),
+        "MIS size_fields should contain num_edges, got: {:?}",
+        size_fields
+    );
     assert!(json["solvers"].is_array());
     assert!(json["reduces_to"].is_array());
 

src/rules/graph.rs

@@ -624,19 +624,25 @@ impl ReductionGraph {
     /// Get the problem size field names for a problem type.
     ///
     /// Derives size fields from the overhead expressions of reduction entries
-    /// where this problem appears as source or target.
+    /// where this problem appears as source or target. When the problem is a
+    /// source, its size fields are the input variables referenced in the overhead
+    /// expressions. When it's a target, its size fields are the output field names.
     pub fn size_field_names(&self, name: &str) -> Vec<&'static str> {
+        let mut fields = std::collections::HashSet::new();
         for entry in inventory::iter::<ReductionEntry> {
             if entry.source_name == name {
-                let overhead = entry.overhead();
-                return overhead.output_size.iter().map(|(name, _)| *name).collect();
+                // Source's size fields are the input variables of the overhead.
+                fields.extend(entry.overhead().input_variable_names());
             }
             if entry.target_name == name {
+                // Target's size fields are the output field names.
                 let overhead = entry.overhead();
-                return overhead.output_size.iter().map(|(name, _)| *name).collect();
+                fields.extend(overhead.output_size.iter().map(|(name, _)| *name));
             }
         }
-        vec![]
+        let mut result: Vec<&'static str> = fields.into_iter().collect();
+        result.sort_unstable();
+        result
     }
 
     /// Get all incoming reductions to a problem (across all its variants).

src/unit_tests/rules/graph.rs

@@ -4,6 +4,7 @@ use crate::models::optimization::QUBO;
 use crate::models::set::MaximumSetPacking;
 use crate::rules::cost::MinimizeSteps;
 use crate::rules::graph::{classify_problem_category, ReductionStep};
+use crate::rules::registry::ReductionEntry;
 use crate::topology::SimpleGraph;
 use crate::traits::Problem;
 use crate::types::ProblemSize;
@@ -979,3 +980,74 @@ fn test_reduction_chain_with_variant_casts() {
     // Verify the extracted solution satisfies the original 3-SAT formula
     assert!(ksat.evaluate(&original_solution));
 }
+
+#[test]
+fn test_size_field_names_returns_own_fields() {
+    let graph = ReductionGraph::new();
+
+    // MIS should report its own fields (num_vertices, num_edges),
+    // not the target's fields from any reduction.
+    let mis_fields = graph.size_field_names("MaximumIndependentSet");
+    assert!(
+        mis_fields.contains(&"num_vertices"),
+        "MIS should have num_vertices, got: {:?}",
+        mis_fields
+    );
+    assert!(
+        mis_fields.contains(&"num_edges"),
+        "MIS should have num_edges, got: {:?}",
+        mis_fields
+    );
+    // Should NOT contain target fields like num_vars or num_constraints
+    assert!(
+        !mis_fields.contains(&"num_constraints"),
+        "MIS should not report ILP's num_constraints, got: {:?}",
+        mis_fields
+    );
+
+    // QUBO should report num_vars
+    let qubo_fields = graph.size_field_names("QUBO");
+    assert!(
+        qubo_fields.contains(&"num_vars"),
+        "QUBO should have num_vars, got: {:?}",
+        qubo_fields
+    );
+
+    // Unknown problem returns empty
+    let unknown_fields = graph.size_field_names("NonExistentProblem");
+    assert!(unknown_fields.is_empty());
+}
+
+#[test]
+fn test_overhead_variables_are_consistent() {
+    // For each reduction, the input variables of the overhead should be
+    // a subset of the source problem's size fields (as derived from all
+    // reductions where it appears).
+    let graph = ReductionGraph::new();
+
+    for entry in inventory::iter::<ReductionEntry> {
+        let overhead = entry.overhead();
+        let input_vars = overhead.input_variable_names();
+        if input_vars.is_empty() {
+            continue;
+        }
+
+        let source_fields: std::collections::HashSet<&str> = graph
+            .size_field_names(entry.source_name)
+            .into_iter()
+            .collect();
+
+        for var in &input_vars {
+            assert!(
+                source_fields.contains(var),
+                "Reduction {} -> {}: overhead references variable '{}' \
+                 which is not a known size field of {}. Known fields: {:?}",
+                entry.source_name,
+                entry.target_name,
+                var,
+                entry.source_name,
+                source_fields
+            );
+        }
+    }
+}