Symbolic growth domain + Pareto search: M1–M3 (#1075, #1078, #1076)

Makefile

@@ -289,10 +289,11 @@ cli-demo: cli
 	$$PRED from QUBO --hops 1; \
 	\
 	echo ""; \
-	echo "--- 5. path: find reduction paths ---"; \
+	echo "--- 5. path: asymptotic Pareto front (no --size) ---"; \
 	$$PRED path MIS QUBO; \
-	$$PRED path MIS QUBO -o $(CLI_DEMO_DIR)/path_mis_qubo.json; \
 	$$PRED path Factoring SpinGlass; \
+	echo "--- 5b. path --cost: single concrete path (for reduce --via) ---"; \
+	$$PRED path MIS QUBO --cost minimize-steps -o $(CLI_DEMO_DIR)/path_mis_qubo.json; \
 	$$PRED path MIS QUBO --cost minimize:num_variables; \
 	\
 	echo ""; \

docs/src/cli.md

@@ -163,7 +163,7 @@ Show all paths or save for later use with `pred reduce --via`:
 ```bash
 pred path MIS QUBO --all                    # all paths (up to 20)
 pred path MIS QUBO --all --max-paths 50     # increase limit
-pred path MIS QUBO -o path.json             # save path for `pred reduce --via`
+pred path MIS QUBO -o path.json             # save front + best path for `pred reduce --via`
 pred path MIS QUBO --all -o paths/          # save all paths to a folder
 ```
 

problemreductions-cli/src/bin/pred_sym.rs

@@ -1,5 +1,5 @@
 use clap::{Parser, Subcommand};
-use problemreductions::{big_o_normal_form, canonical_form, Expr, ProblemSize};
+use problemreductions::{big_o_normal_form, Expr, ProblemSize};
 
 #[derive(Parser)]
 #[command(
@@ -19,11 +19,6 @@ enum Commands {
         /// Expression string
         expr: String,
     },
-    /// Compute exact canonical form
-    Canon {
-        /// Expression string
-        expr: String,
-    },
     /// Compute Big-O normal form
     BigO {
         /// Expression string
@@ -33,7 +28,7 @@ enum Commands {
         #[arg(long)]
         raw: bool,
     },
-    /// Compare two expressions (exits with code 1 if neither exact nor Big-O equal)
+    /// Compare two expressions for Big-O equivalence (exits 1 if not equal)
     Compare {
         /// First expression
         a: String,
@@ -69,16 +64,6 @@ fn main() {
             let parsed = parse_expr_or_exit(&expr);
             println!("{parsed}");
         }
-        Commands::Canon { expr } => {
-            let parsed = parse_expr_or_exit(&expr);
-            match canonical_form(&parsed) {
-                Ok(result) => println!("{result}"),
-                Err(e) => {
-                    eprintln!("Error: {e}");
-                    std::process::exit(1);
-                }
-            }
-        }
         Commands::BigO { expr, raw } => {
             let parsed = parse_expr_or_exit(&expr);
             match big_o_normal_form(&parsed) {
@@ -98,29 +83,31 @@ fn main() {
         Commands::Compare { a, b } => {
             let expr_a = parse_expr_or_exit(&a);
             let expr_b = parse_expr_or_exit(&b);
-            let canon_a = canonical_form(&expr_a);
-            let canon_b = canonical_form(&expr_b);
             let big_o_a = big_o_normal_form(&expr_a);
             let big_o_b = big_o_normal_form(&expr_b);
 
             println!("Expression A: {a}");
             println!("Expression B: {b}");
-            let mut exact_equal = false;
-            let mut big_o_equal = false;
-            if let (Ok(ca), Ok(cb)) = (&canon_a, &canon_b) {
-                exact_equal = ca == cb;
-                println!("Canonical A:  {ca}");
-                println!("Canonical B:  {cb}");
-                println!("Exact equal:  {exact_equal}");
-            }
-            if let (Ok(ba), Ok(bb)) = (&big_o_a, &big_o_b) {
-                big_o_equal = ba == bb;
-                println!("Big-O A:      O({ba})");
-                println!("Big-O B:      O({bb})");
-                println!("Big-O equal:  {big_o_equal}");
-            }
-            if !exact_equal && !big_o_equal {
-                std::process::exit(1);
+            match (&big_o_a, &big_o_b) {
+                (Ok(ba), Ok(bb)) => {
+                    // Rendering is canonical, so equal growth ⇒ equal Big-O expr.
+                    let big_o_equal = ba == bb;
+                    println!("Big-O A:      O({ba})");
+                    println!("Big-O B:      O({bb})");
+                    println!("Big-O equal:  {big_o_equal}");
+                    if !big_o_equal {
+                        std::process::exit(1);
+                    }
+                }
+                _ => {
+                    if let Err(e) = &big_o_a {
+                        println!("Big-O A:      <unsupported: {e}>");
+                    }
+                    if let Err(e) = &big_o_b {
+                        println!("Big-O B:      <unsupported: {e}>");
+                    }
+                    std::process::exit(1);
+                }
             }
         }
         Commands::Eval { expr, vars } => {

problemreductions-cli/src/cli.rs

@@ -112,11 +112,11 @@ Use `pred to <problem>` for incoming neighbors (what reduces to this).")]
     /// Find the cheapest reduction path between two problems
     #[command(after_help = "\
 Examples:
-  pred path MIS QUBO                              # cheapest path
+  pred path MIS QUBO                              # asymptotic Pareto front (Big-O per size field)
   pred path MIS QUBO --all                        # all paths
-  pred path MIS QUBO -o path.json                 # save for `pred reduce --via`
+  pred path MIS QUBO -o path.json                 # save front + best path for `pred reduce --via`
   pred path MIS QUBO --all -o paths/              # save all paths to a folder
-  pred path MIS QUBO --cost minimize:num_variables
+  pred path MIS QUBO --cost minimize:num_variables  # single cheapest path by a scalar cost (also -o for --via)
 
 Use `pred list` to see available problems.")]
     Path {
@@ -126,9 +126,10 @@ Use `pred list` to see available problems.")]
         /// Target problem (e.g., QUBO)
         #[arg(value_parser = crate::problem_name::ProblemNameParser)]
         target: String,
-        /// Cost function [default: minimize-steps]
-        #[arg(long, default_value = "minimize-steps")]
-        cost: String,
+        /// Scalar cost function ('minimize-steps' or 'minimize:<field>') for a single
+        /// best path. Omit to get the instance-free asymptotic Pareto front.
+        #[arg(long)]
+        cost: Option<String>,
         /// Show all paths instead of just the cheapest
         #[arg(long)]
         all: bool,
@@ -1273,7 +1274,8 @@ Examples:
   pred create MIS --graph 0-1,1-2 | pred reduce - --to QUBO  # read from stdin
 
 Input: a problem JSON from `pred create`. Use - to read from stdin.
-The --via path file is from `pred path <SRC> <DST> -o path.json`.
+The --via path file is from `pred path <SRC> <DST> -o path.json` (its
+top-level `path` is the best path; add --cost to pick a scalar-optimal one).
 When --via is given, --to is inferred from the path file.
 Output is a reduction bundle with source, target, and path.
 Use `pred solve reduced.json` to solve and map the solution back.")]