Add variant-level aliases; introduce 2SAT and 3SAT

Variant-level aliases attach to a specific reduction-graph node rather
than a canonical problem name, so shorthand like `3SAT` can resolve to
`KSatisfiability<K3>` directly instead of going through the problem's
default variant (which is `KN`, not what `3SAT` means in the literature).

- `VariantEntry` gains an `aliases: &'static [&'static str]` field.
- `declare_variants!` accepts optional `aliases ["X", ...]` trailing each
  entry and emits the field.
- `registry::find_variant_by_alias()` returns both the entry and its
  variant map.
- CLI `parse_problem_spec` and `resolve_alias` try variant-level aliases
  before problem-level ones, injecting the alias's variant tokens into
  the spec; problem-level resolution is unchanged for `MIS`, `SAT`, etc.
- Adds `2SAT` on `KSatisfiability<K2>` and `3SAT` on `KSatisfiability<K3>`.
- `pred list` now shows variant-level aliases on their own rows.
- `MAX2SAT` remains a problem-level alias on `Maximum2Satisfiability`
  (standalone problem, no variants).

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: GiggleLiu

problemreductions-cli/src/commands/create/schema_support.rs

@@ -180,9 +180,7 @@ pub(super) fn create_schema_driven(
 
     // KColoring/KN stores the number of colors at runtime in `num_colors`.
     // The schema only declares `graph`, so inject `num_colors` from --k for KN.
-    if canonical == "KColoring"
-        && resolved_variant.get("k").map(|s| s.as_str()) == Some("KN")
-    {
+    if canonical == "KColoring" && resolved_variant.get("k").map(|s| s.as_str()) == Some("KN") {
         if let Some(k) = args.k {
             json_map.insert("num_colors".to_string(), serde_json::json!(k));
         }

problemreductions-cli/src/commands/graph.rs

@@ -33,12 +33,7 @@ pub fn list(out: &OutputConfig) -> Result<()> {
     for name in &types {
         let variants = graph.variants_for(name);
         let default_variant = graph.default_variant_for(name);
-        let aliases = aliases_for(name);
-        let alias_str = if aliases.is_empty() {
-            String::new()
-        } else {
-            aliases.join(", ")
-        };
+        let problem_aliases = aliases_for(name);
 
         for (i, v) in variants.iter().enumerate() {
             let slash = variant_to_full_slash(v);
@@ -53,13 +48,22 @@ pub fn list(out: &OutputConfig) -> Result<()> {
                 .variant_complexity(name, v)
                 .map(|c| big_o_of(&Expr::parse(c)))
                 .unwrap_or_default();
+
+            // Per-row aliases: problem-level aliases on the first row, plus any
+            // variant-level aliases attached to the specific reduction-graph node.
+            let variant_aliases: Vec<&'static str> =
+                problemreductions::registry::find_variant_entry(name, v)
+                    .map(|entry| entry.aliases.to_vec())
+                    .unwrap_or_default();
+            let mut parts: Vec<String> = Vec::new();
+            if i == 0 {
+                parts.extend(problem_aliases.iter().map(|s| s.to_string()));
+            }
+            parts.extend(variant_aliases.iter().map(|s| s.to_string()));
+
             rows_data.push(VariantRow {
                 display,
-                aliases: if i == 0 {
-                    alias_str.clone()
-                } else {
-                    String::new()
-                },
+                aliases: parts.join(", "),
                 is_default,
                 rules: if i == 0 { rules } else { 0 },
                 complexity,

problemreductions-cli/src/problem_name.rs

@@ -12,7 +12,10 @@ pub struct ProblemSpec {
 
 /// Resolve a short alias to the canonical problem name.
 ///
-/// Uses the catalog for both aliases and canonical names.
+/// Searches both variant-level aliases (e.g., `"3SAT"` → `KSatisfiability`) and
+/// problem-level aliases (e.g., `"MIS"` → `MaximumIndependentSet`). When a
+/// variant-level alias is matched, only the canonical name is returned here;
+/// use [`parse_problem_spec`] to also recover the variant tokens.
 pub fn resolve_alias(input: &str) -> String {
     if input.eq_ignore_ascii_case("UndirectedFlowLowerBounds") {
         return "UndirectedFlowLowerBounds".to_string();
@@ -38,6 +41,9 @@ pub fn resolve_alias(input: &str) -> String {
     if input.eq_ignore_ascii_case("GraphPartitioning") {
         return "GraphPartitioning".to_string();
     }
+    if let Some((entry, _)) = problemreductions::registry::find_variant_by_alias(input) {
+        return entry.name.to_string();
+    }
     if let Some(pt) = problemreductions::registry::find_problem_type_by_alias(input) {
         return pt.canonical_name.to_string();
     }
@@ -64,16 +70,34 @@ pub fn resolve_catalog_problem_ref(
 }
 
 /// Parse a problem spec string like "MIS/UnitDiskGraph/i32" into name + variant values.
+///
+/// Resolution order:
+/// 1. **Variant-level alias** (`"3SAT"` → `KSatisfiability` + variant tokens `["K3"]`):
+///    injects the variant tokens *before* any user-supplied tokens from the slash spec.
+/// 2. **Problem-level alias** (`"MIS"` → `MaximumIndependentSet`): canonical-name only;
+///    downstream default-variant resolution fills in the variant dimensions.
 pub fn parse_problem_spec(input: &str) -> anyhow::Result<ProblemSpec> {
     let parts: Vec<&str> = input.split('/').collect();
     let raw_name = parts[0];
-    let variant_values: Vec<String> = parts[1..].iter().map(|s| s.to_string()).collect();
+    let user_tokens: Vec<String> = parts[1..].iter().map(|s| s.to_string()).collect();
+
+    if let Some((entry, variant_map)) = problemreductions::registry::find_variant_by_alias(raw_name)
+    {
+        // Prepend the alias's own variant values; the slash-spec resolver handles
+        // additional user tokens (and errors on dimension collisions).
+        let mut variant_values: Vec<String> = variant_map.into_values().collect();
+        variant_values.extend(user_tokens);
+        return Ok(ProblemSpec {
+            name: entry.name.to_string(),
+            variant_values,
+        });
+    }
 
     let name = resolve_alias(raw_name);
 
     Ok(ProblemSpec {
         name,
-        variant_values,
+        variant_values: user_tokens,
     })
 }
 
@@ -301,8 +325,11 @@ mod tests {
         assert_eq!(resolve_alias("X3C"), "ExactCoverBy3Sets");
         assert_eq!(resolve_alias("3Partition"), "ThreePartition");
         assert_eq!(resolve_alias("3-partition"), "ThreePartition");
-        // 3SAT is no longer a registered alias (removed to avoid confusion with KSatisfiability/KN)
-        assert_eq!(resolve_alias("3SAT"), "3SAT"); // pass-through
+        // Variant-level aliases: resolve_alias only returns the canonical name;
+        // parse_problem_spec recovers the variant tokens (see tests below).
+        assert_eq!(resolve_alias("3SAT"), "KSatisfiability");
+        assert_eq!(resolve_alias("3sat"), "KSatisfiability");
+        assert_eq!(resolve_alias("2SAT"), "KSatisfiability");
         assert_eq!(resolve_alias("QUBO"), "QUBO");
         assert_eq!(resolve_alias("MaxCut"), "MaxCut");
         assert_eq!(
@@ -372,6 +399,34 @@ mod tests {
         assert_eq!(spec.variant_values, vec!["K3"]);
     }
 
+    #[test]
+    fn test_parse_problem_spec_variant_alias_3sat() {
+        // Variant-level alias: "3SAT" injects the K3 variant token.
+        let spec = parse_problem_spec("3SAT").unwrap();
+        assert_eq!(spec.name, "KSatisfiability");
+        assert_eq!(spec.variant_values, vec!["K3"]);
+
+        let spec = parse_problem_spec("3sat").unwrap();
+        assert_eq!(spec.name, "KSatisfiability");
+        assert_eq!(spec.variant_values, vec!["K3"]);
+    }
+
+    #[test]
+    fn test_parse_problem_spec_variant_alias_2sat() {
+        let spec = parse_problem_spec("2SAT").unwrap();
+        assert_eq!(spec.name, "KSatisfiability");
+        assert_eq!(spec.variant_values, vec!["K2"]);
+    }
+
+    #[test]
+    fn test_parse_problem_spec_max2sat_problem_level() {
+        // MAX2SAT is a problem-level alias on Maximum2Satisfiability (standalone problem,
+        // no K variants) — no variant tokens injected.
+        let spec = parse_problem_spec("MAX2SAT").unwrap();
+        assert_eq!(spec.name, "Maximum2Satisfiability");
+        assert!(spec.variant_values.is_empty());
+    }
+
     #[test]
     fn test_suggest_problem_name_close() {
         // "MISs" is 1 edit from "MIS" alias -> should suggest MaximumIndependentSet

problemreductions-cli/src/test_support.rs

@@ -126,6 +126,7 @@ problemreductions::inventory::submit! {
         complexity: "2^num_values",
         complexity_eval_fn: |_| 1.0,
         is_default: true,
+        aliases: &[],
         factory: |data| {
             let problem: AggregateValueSource = serde_json::from_value(data)?;
             Ok(Box::new(problem))
@@ -146,6 +147,7 @@ problemreductions::inventory::submit! {
         complexity: "2",
         complexity_eval_fn: |_| 1.0,
         is_default: true,
+        aliases: &[],
         factory: |data| {
             let problem: AggregateValueTarget = serde_json::from_value(data)?;
             Ok(Box::new(problem))

problemreductions-macros/src/lib.rs

@@ -444,11 +444,12 @@ struct DeclareVariantsInput {
     entries: Vec<DeclareVariantEntry>,
 }
 
-/// A single entry: `[default] Type => "complexity_string"`.
+/// A single entry: `[default] Type => "complexity_string" [aliases ["X", ...]]`.
 struct DeclareVariantEntry {
     is_default: bool,
     ty: Type,
     complexity: syn::LitStr,
+    aliases: Vec<syn::LitStr>,
 }
 
 impl syn::parse::Parse for DeclareVariantsInput {
@@ -464,10 +465,35 @@ impl syn::parse::Parse for DeclareVariantsInput {
             let ty: Type = input.parse()?;
             input.parse::<syn::Token![=>]>()?;
             let complexity: syn::LitStr = input.parse()?;
+
+            // Optional: `aliases ["X", "Y", ...]`
+            let aliases = if input.peek(syn::Ident) {
+                let ident: syn::Ident = input.fork().parse()?;
+                if ident == "aliases" {
+                    input.parse::<syn::Ident>()?;
+                    let content;
+                    syn::bracketed!(content in input);
+                    let mut out = Vec::new();
+                    while !content.is_empty() {
+                        let lit: syn::LitStr = content.parse()?;
+                        out.push(lit);
+                        if content.peek(syn::Token![,]) {
+                            content.parse::<syn::Token![,]>()?;
+                        }
+                    }
+                    out
+                } else {
+                    Vec::new()
+                }
+            } else {
+                Vec::new()
+            };
+
             entries.push(DeclareVariantEntry {
                 is_default,
                 ty,
                 complexity,
+                aliases,
             });
 
             if input.peek(syn::Token![,]) {
@@ -552,6 +578,7 @@ fn generate_declare_variants(input: &DeclareVariantsInput) -> syn::Result<TokenS
         let ty = &entry.ty;
         let complexity_str = entry.complexity.value();
         let is_default = entry.is_default;
+        let alias_lits: Vec<_> = entry.aliases.iter().map(|s| s.value()).collect();
 
         // Parse the complexity expression to validate syntax
         let parsed = parser::parse_expr(&complexity_str).map_err(|e| {
@@ -633,6 +660,7 @@ fn generate_declare_variants(input: &DeclareVariantsInput) -> syn::Result<TokenS
                     complexity: #complexity_str,
                     complexity_eval_fn: #complexity_eval_fn,
                     is_default: #is_default,
+                    aliases: &[#(#alias_lits),*],
                     #dispatch_fields
                 }
             }

src/models/formula/ksat.rs

@@ -241,8 +241,8 @@ impl<K: KValue> Problem for KSatisfiability<K> {
 
 crate::declare_variants! {
     default KSatisfiability<KN> => "2^num_variables",
-    KSatisfiability<K2> => "num_variables + num_clauses",
-    KSatisfiability<K3> => "1.307^num_variables",
+    KSatisfiability<K2> => "num_variables + num_clauses" aliases ["2SAT"],
+    KSatisfiability<K3> => "1.307^num_variables" aliases ["3SAT"],
 }
 
 #[cfg(feature = "example-db")]

src/models/graph/minimum_dominating_set.rs

@@ -244,6 +244,7 @@ inventory::submit! {
             1.4969_f64.powf(problem.num_vertices() as f64)
         },
         is_default: false,
+        aliases: &[],
         factory: |data| {
             serde_json::from_value::<Decision<MinimumDominatingSet<SimpleGraph, One>>>(data)
                 .map(|problem| Box::new(problem) as Box<dyn crate::registry::DynProblem>)

src/registry/mod.rs

@@ -59,7 +59,7 @@ pub use schema::{
     collect_schemas, declared_size_fields, FieldInfoJson, ProblemSchemaEntry, ProblemSchemaJson,
     ProblemSizeFieldEntry, VariantDimension,
 };
-pub use variant::{find_variant_entry, VariantEntry};
+pub use variant::{find_variant_by_alias, find_variant_entry, VariantEntry};
 
 use std::any::Any;
 use std::collections::BTreeMap;

src/registry/variant.rs

@@ -22,6 +22,12 @@ pub struct VariantEntry {
     pub complexity_eval_fn: fn(&dyn Any) -> f64,
     /// Whether this entry is the declared default variant for its problem.
     pub is_default: bool,
+    /// Variant-level aliases (e.g., `&["3SAT"]` for `KSatisfiability<K3>`).
+    ///
+    /// Unlike problem-level aliases (on `ProblemSchemaEntry`), these resolve to a
+    /// specific reduction-graph node, not just to a canonical problem name. The CLI
+    /// resolver tries variant-level aliases first and falls back to problem-level.
+    pub aliases: &'static [&'static str],
     /// Factory: deserialize JSON into a boxed dynamic problem.
     pub factory: fn(serde_json::Value) -> Result<Box<dyn DynProblem>, serde_json::Error>,
     /// Serialize: downcast `&dyn Any` and serialize to JSON.
@@ -58,6 +64,23 @@ pub fn find_variant_entry(
         .find(|entry| entry.name == name && entry.variant_map() == *variant)
 }
 
+/// Find a variant entry by a variant-level alias (case-insensitive).
+///
+/// A variant-level alias points at a specific reduction-graph node (e.g., `"3SAT"` →
+/// `KSatisfiability` with variant `{k: "K3"}`), unlike problem-level aliases which
+/// resolve only to a canonical problem name.
+///
+/// Returns the matched entry along with its variant map. The first match in registration
+/// order wins — duplicate variant-level aliases across problems are a declaration bug.
+pub fn find_variant_by_alias(
+    input: &str,
+) -> Option<(&'static VariantEntry, BTreeMap<String, String>)> {
+    let lower = input.to_lowercase();
+    let entry = inventory::iter::<VariantEntry>()
+        .find(|entry| entry.aliases.iter().any(|a| a.to_lowercase() == lower))?;
+    Some((entry, entry.variant_map()))
+}
+
 impl std::fmt::Debug for VariantEntry {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("VariantEntry")