Hide advanced sorting configuration options (#11)

* Hide advanced sorting configuration options from help

Simplifies the user interface by hiding detailed sorting config options.
Users only see --no-sort as the main control, but advanced options
remain functional if you know about them.

Hidden from help (but still work):
- --skip-sgd, --skip-groom, --skip-topo
- --sgd-iter-max, --sgd-eta-max
- --sgd-theta, --sgd-eps, --sgd-cooling-start

Visible:
- --no-sort (simple on/off for all sorting)

This keeps the interface clean for most users while preserving
advanced configuration for developers and power users.

* Improve sparsification parameter naming and clean up legacy code

- Updated sparsification format from 'tree:K,K2,F,SIZE' to 'tree:neighbor,stranger,random,k-mer'
  for clearer parameter names (neighbor=k-nearest, stranger=k-farthest)

- Removed legacy sparsification parsing code that was causing confusing error messages
  when using tree sampling

- Removed unused sparsity_threshold field from SeqRush struct - sparsification now
  handled entirely at the aligner level through SparsificationStrategy enum

- Updated all test code to match new SeqRush::new() signature

This eliminates the "Invalid sparsification value" warning that appeared when
using tree sampling, making the output cleaner.

* Support short forms of tree sparsification parameter

Allow shorter forms of tree sampling for convenience:
- tree:3            → TreeSampling(3, 0, 0.0, 16)
- tree:3,2          → TreeSampling(3, 2, 0.0, 16)
- tree:3,2,0.1      → TreeSampling(3, 2, 0.1, 16)
- tree:3,2,0.1,21   → TreeSampling(3, 2, 0.1, 21)

Defaults:
- stranger count: 0
- random fraction: 0.0
- k-mer size: 16

This makes the most common case (just specifying k-nearest neighbors)
much simpler to type.

Author: ekg

src/bin/test_duplicate_edges.rs

@@ -18,7 +18,7 @@ fn main() {
         offset: 5,
     };
 
-    let mut seqrush = SeqRush::new(vec![seq1, seq2], 0);
+    let mut seqrush = SeqRush::new(vec![seq1, seq2]);
 
     // Unite some positions to create shared nodes
     // Make it so node 2 and 3 are shared between sequences

src/bin/test_rc_edges.rs

@@ -19,7 +19,7 @@ fn main() {
         offset: 4,
     };
 
-    let mut seqrush = SeqRush::new(vec![seq1, seq2], 0);
+    let mut seqrush = SeqRush::new(vec![seq1, seq2]);
 
     // Unite them via RC alignment
     // When seq1 is RC'd, it becomes CGAT which matches seq2

src/seqrush.rs

@@ -65,8 +65,8 @@ pub struct Args {
     #[arg(long = "no-compact", default_value = "false")]
     pub no_compact: bool,
 
-    /// Sparsification strategy: 'none', 'auto', 'random:F', 'connectivity:F', 'tree:K,K2,F,SIZE'
-    /// Examples: 'none' (all pairs), 'random:0.5' (50% random), 'tree:3,3,0.1,16' (tree sampling)
+    /// Sparsification strategy: 'none', 'auto', 'random:F', 'connectivity:F', 'tree:neighbor[,stranger[,random[,k-mer]]]'
+    /// Examples: 'none' (all pairs), 'random:0.5' (50% random), 'tree:3' (3 nearest), 'tree:3,2' (3 nearest, 2 farthest), 'tree:3,3,0.1,16' (full)
     #[arg(short = 'x', long = "sparsify", default_value = "none")]
     pub sparsification: String,
 
@@ -87,35 +87,35 @@ pub struct Args {
     pub no_sort: bool,
 
     /// Skip the path-guided SGD phase (Y) of the Ygs pipeline
-    #[arg(long = "skip-sgd", default_value = "false")]
+    #[arg(long = "skip-sgd", default_value = "false", hide = true)]
     pub skip_sgd: bool,
 
     /// Skip the grooming phase (g) of the Ygs pipeline
-    #[arg(long = "skip-groom", default_value = "false")]
+    #[arg(long = "skip-groom", default_value = "false", hide = true)]
     pub skip_groom: bool,
 
     /// Skip the topological sort phase (s) of the Ygs pipeline
-    #[arg(long = "skip-topo", default_value = "false")]
+    #[arg(long = "skip-topo", default_value = "false", hide = true)]
     pub skip_topo: bool,
 
     /// Number of SGD iterations (default: 100, matching ODGI)
-    #[arg(long = "sgd-iter-max", default_value = "100")]
+    #[arg(long = "sgd-iter-max", default_value = "100", hide = true)]
     pub sgd_iter_max: u64,
 
     /// SGD learning rate parameter eta_max (default: calculated from graph)
-    #[arg(long = "sgd-eta-max")]
+    #[arg(long = "sgd-eta-max", hide = true)]
     pub sgd_eta_max: Option<f64>,
 
     /// SGD cooling/momentum parameter theta (default: 0.99)
-    #[arg(long = "sgd-theta", default_value = "0.99")]
+    #[arg(long = "sgd-theta", default_value = "0.99", hide = true)]
     pub sgd_theta: f64,
 
     /// SGD convergence parameter eps (default: 0.01)
-    #[arg(long = "sgd-eps", default_value = "0.01")]
+    #[arg(long = "sgd-eps", default_value = "0.01", hide = true)]
     pub sgd_eps: f64,
 
     /// SGD cooling start (default: 0.5)
-    #[arg(long = "sgd-cooling-start", default_value = "0.5")]
+    #[arg(long = "sgd-cooling-start", default_value = "0.5", hide = true)]
     pub sgd_cooling_start: f64,
 
     /// [DEPRECATED] Use sort-groom-sort strategy (use --skip-* flags instead)
@@ -299,14 +299,13 @@ pub struct SeqRush {
     pub sequences: Vec<Sequence>,
     pub total_length: usize,
     pub union_find: BidirectedUnionFind,
-    pub sparsity_threshold: u64,
     /// Maps each position to its orientation relative to its union representative
     /// true = reverse orientation relative to representative
     pub orientation_map: HashMap<Pos, bool>,
 }
 
 impl SeqRush {
-    pub fn new(sequences: Vec<Sequence>, sparsity_threshold: u64) -> Self {
+    pub fn new(sequences: Vec<Sequence>) -> Self {
         // Validate that no sequences are empty
         for seq in &sequences {
             if seq.data.is_empty() {
@@ -332,7 +331,6 @@ impl SeqRush {
             sequences,
             total_length,
             union_find,
-            sparsity_threshold,
             orientation_map: HashMap::new(),
         }
     }
@@ -379,24 +377,45 @@ impl SeqRush {
             }
             s if s.starts_with("tree:") => {
                 let parts: Vec<&str> = s[5..].split(',').collect();
-                if parts.len() != 4 {
-                    return Err(format!("Tree sampling requires 4 values: tree:K_NEAR,K_FAR,RAND_FRAC,KMER_SIZE, got {}", s).into());
+                if parts.is_empty() || parts.len() > 4 {
+                    return Err(format!("Tree sampling requires 1-4 values: tree:neighbor[,stranger[,random[,k-mer]]], got {}", s).into());
                 }
+
+                // Parse neighbor (required)
                 let k_nearest: usize = parts[0].parse()
-                    .map_err(|_| format!("Invalid k_nearest: {}", parts[0]))?;
-                let k_farthest: usize = parts[1].parse()
-                    .map_err(|_| format!("Invalid k_farthest: {}", parts[1]))?;
-                let rand_frac: f64 = parts[2].parse()
-                    .map_err(|_| format!("Invalid random_fraction: {}", parts[2]))?;
-                let kmer_size: usize = parts[3].parse()
-                    .map_err(|_| format!("Invalid kmer_size: {}", parts[3]))?;
-
-                if rand_frac < 0.0 || rand_frac > 1.0 {
-                    return Err(format!("Random fraction must be in [0.0, 1.0], got {}", rand_frac).into());
-                }
-                if kmer_size == 0 {
-                    return Err("Kmer size must be > 0".into());
-                }
+                    .map_err(|_| format!("Invalid neighbor count: {}", parts[0]))?;
+
+                // Parse stranger (default: 0)
+                let k_farthest: usize = if parts.len() >= 2 {
+                    parts[1].parse()
+                        .map_err(|_| format!("Invalid stranger count: {}", parts[1]))?
+                } else {
+                    0
+                };
+
+                // Parse random fraction (default: 0.0)
+                let rand_frac: f64 = if parts.len() >= 3 {
+                    let frac = parts[2].parse()
+                        .map_err(|_| format!("Invalid random fraction: {}", parts[2]))?;
+                    if frac < 0.0 || frac > 1.0 {
+                        return Err(format!("Random fraction must be in [0.0, 1.0], got {}", frac).into());
+                    }
+                    frac
+                } else {
+                    0.0
+                };
+
+                // Parse k-mer size (default: 16)
+                let kmer_size: usize = if parts.len() >= 4 {
+                    let size = parts[3].parse()
+                        .map_err(|_| format!("Invalid k-mer size: {}", parts[3]))?;
+                    if size == 0 {
+                        return Err("K-mer size must be > 0".into());
+                    }
+                    size
+                } else {
+                    16
+                };
 
                 Ok(SparsificationStrategy::TreeSampling(k_nearest, k_farthest, rand_frac, Some(kmer_size)))
             }
@@ -406,7 +425,7 @@ impl SeqRush {
                     eprintln!("Warning: Plain float deprecated. Use 'random:{}' instead", factor);
                     Ok(SparsificationStrategy::Random(factor))
                 }
-                _ => Err(format!("Invalid sparsification: '{}'. Use 'none', 'auto', 'random:F', 'connectivity:F', or 'tree:K,K2,F,SIZE'", s).into())
+                _ => Err(format!("Invalid sparsification: '{}'. Use 'none', 'auto', 'random:F', 'connectivity:F', or 'tree:neighbor[,stranger[,random[,k-mer]]]'", s).into())
             }
         }
     }
@@ -1826,41 +1845,7 @@ pub fn run_seqrush(args: Args) -> Result<(), Box<dyn std::error::Error>> {
     let sequences = load_sequences(&args.sequences)?;
     println!("Loaded {} sequences", sequences.len());
 
-    // Calculate sparsification threshold
-    let sparsity_threshold = if args.sparsification == "auto" {
-        // Use Erdős-Rényi model: keep 10 * log(n) / n fraction of alignment pairs
-        let n = sequences.len() as f64;
-        let fraction = (10.0 * n.ln() / n).min(1.0);
-        println!(
-            "Auto sparsification: keeping {:.2}% of alignment pairs (n={})",
-            fraction * 100.0,
-            sequences.len()
-        );
-        (fraction * u64::MAX as f64) as u64
-    } else {
-        match args.sparsification.parse::<f64>() {
-            Ok(frac) if (0.0..=1.0).contains(&frac) => {
-                if frac == 1.0 {
-                    u64::MAX
-                } else {
-                    println!(
-                        "Sparsification: keeping {:.2}% of alignment pairs",
-                        frac * 100.0
-                    );
-                    (frac * u64::MAX as f64) as u64
-                }
-            }
-            _ => {
-                eprintln!(
-                    "Invalid sparsification value: {}. Using 1.0 (no sparsification)",
-                    args.sparsification
-                );
-                u64::MAX
-            }
-        }
-    };
-
-    let mut seqrush = SeqRush::new(sequences, sparsity_threshold);
+    let mut seqrush = SeqRush::new(sequences);
     seqrush.build_graph(&args);
 
     println!("Graph written to {}", args.output);

tests/test_mathematical_correctness.rs

@@ -11,7 +11,7 @@ fn test_forward_reverse_unification() {
         offset: 0,
     };
 
-    let seqrush = SeqRush::new(vec![seq], 0);
+    let seqrush = SeqRush::new(vec![seq]);
 
     // Check that forward and reverse of each position have the same representative
     for i in 0..4 {
@@ -52,7 +52,7 @@ fn test_transitive_closure() {
         offset: 8,
     };
 
-    let seqrush = SeqRush::new(vec![seq1, seq2, seq3], 0);
+    let seqrush = SeqRush::new(vec![seq1, seq2, seq3]);
 
     // Unite seq1[0] with seq2[0]
     seqrush
@@ -90,7 +90,7 @@ fn test_single_component_per_position() {
         },
     ];
 
-    let seqrush = SeqRush::new(sequences, 0);
+    let seqrush = SeqRush::new(sequences);
 
     // Unite matching positions
     seqrush
@@ -132,7 +132,7 @@ fn test_reverse_complement_alignment() {
         offset: 4,
     };
 
-    let seqrush = SeqRush::new(vec![seq1, seq2], 0);
+    let seqrush = SeqRush::new(vec![seq1, seq2]);
 
     // seq1 aligns to seq2 via reverse complement
     // seq1[0..4] RC aligns to seq2[0..4]
@@ -186,7 +186,7 @@ fn test_identical_sequences_produce_minimal_components() {
         },
     ];
 
-    let seqrush = SeqRush::new(sequences, 0);
+    let seqrush = SeqRush::new(sequences);
 
     // Unite all matching positions
     seqrush
@@ -230,7 +230,7 @@ fn test_no_false_unifications() {
         },
     ];
 
-    let seqrush = SeqRush::new(sequences, 0);
+    let seqrush = SeqRush::new(sequences);
 
     // Without any alignments, positions from different sequences should not be united
     let pos1 = make_pos(0, false);
@@ -264,7 +264,7 @@ fn test_partial_alignment() {
         offset: 12,
     };
 
-    let seqrush = SeqRush::new(vec![seq1, seq2], 0);
+    let seqrush = SeqRush::new(vec![seq1, seq2]);
 
     // Only the GGGG region matches (positions 4-7 in seq1, 4-7 in seq2)
     seqrush