fix: tighten LCS complexity to 2^min_string_length, add edge-case tests

- Change declare_variants! from 2^total_length to 2^min_string_length
  (actual brute-force enumerates subsequences of shortest string)
- Make min_string_length() public getter (was private shortest_len)
- Add #[should_panic] test for empty input
- Add edge-case test for empty string in input
- Fix paper text to reference shortest string length, not total

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

Author: zazabap

docs/paper/reductions.typ

@@ -890,7 +890,7 @@ Biclique Cover is equivalent to factoring the biadjacency matrix $M$ of the bipa
 #problem-def("LongestCommonSubsequence")[
   Given a finite alphabet $Sigma$ and $k$ strings $s_1, dots, s_k$ over $Sigma$, find a longest string $w$ that is a subsequence of every $s_i$. A string $w$ is a _subsequence_ of $s$ if $w$ can be obtained by deleting zero or more characters from $s$ without changing the order of the remaining characters.
 ][
-  The Longest Common Subsequence (LCS) problem is one of the fundamental string problems in computer science, listed as SR10 in @garey1979. For $k = 2$ strings, it is solvable in $O(m n)$ time via dynamic programming @wagner1974. However, Maier @maier1978 proved that the problem is NP-hard when $k$ is part of the input, even over a binary alphabet. LCS is central to diff and version control (e.g., `git diff`), bioinformatics (DNA/protein alignment), and data compression. The best known exact algorithm for the general $k$-string case runs in $O^*(2^n)$ by brute-force enumeration over subsequences of the shortest string#footnote[No algorithm improving on brute-force enumeration is known for the general $k$-string LCS.], where $n$ is the total length of all strings.
+  The Longest Common Subsequence (LCS) problem is one of the fundamental string problems in computer science, listed as SR10 in @garey1979. For $k = 2$ strings, it is solvable in $O(m n)$ time via dynamic programming @wagner1974. However, Maier @maier1978 proved that the problem is NP-hard when $k$ is part of the input, even over a binary alphabet. LCS is central to diff and version control (e.g., `git diff`), bioinformatics (DNA/protein alignment), and data compression. The best known exact algorithm for the general $k$-string case runs in $O^*(2^m)$ by brute-force enumeration over subsequences of the shortest string#footnote[No algorithm improving on brute-force enumeration is known for the general $k$-string LCS.], where $m = min_i |s_i|$ is the length of the shortest string.
 
   *Example.* Consider $k = 3$ strings over $Sigma = {A, B, C, D}$: $s_1 = mono("ABCDAB")$, $s_2 = mono("BDCABA")$, $s_3 = mono("BCADBA")$. An optimal common subsequence is $w = mono("BCAB")$ with length 4. We verify that $w$ is a subsequence of each string by identifying matching positions:
 

src/models/misc/longest_common_subsequence.rs

@@ -95,8 +95,8 @@ impl LongestCommonSubsequence {
             .unwrap_or(0)
     }
 
-    /// Length of the shortest string.
-    fn shortest_len(&self) -> usize {
+    /// Length of the shortest string (upper bound on LCS length).
+    pub fn min_string_length(&self) -> usize {
         self.strings.iter().map(|s| s.len()).min().unwrap_or(0)
     }
 }
@@ -110,7 +110,7 @@ impl Problem for LongestCommonSubsequence {
     }
 
     fn dims(&self) -> Vec<usize> {
-        vec![2; self.shortest_len()]
+        vec![2; self.min_string_length()]
     }
 
     fn evaluate(&self, config: &[usize]) -> SolutionSize<i32> {
@@ -162,7 +162,7 @@ fn is_subsequence(sub: &[u8], full: &[u8]) -> bool {
 }
 
 crate::declare_variants! {
-    LongestCommonSubsequence => "2^total_length",
+    LongestCommonSubsequence => "2^min_string_length",
 }
 
 #[cfg(test)]

src/unit_tests/models/misc/longest_common_subsequence.rs

@@ -141,3 +141,19 @@ fn test_lcs_serialization() {
     let restored: LongestCommonSubsequence = serde_json::from_value(json).unwrap();
     assert_eq!(restored.strings(), problem.strings());
 }
+
+#[test]
+#[should_panic(expected = "must have at least one string")]
+fn test_lcs_empty_strings_panics() {
+    LongestCommonSubsequence::new(vec![]);
+}
+
+#[test]
+fn test_lcs_empty_string_in_input() {
+    // One empty string means LCS is always empty
+    let problem = LongestCommonSubsequence::new(vec![vec![], vec![b'A', b'B']]);
+    assert_eq!(problem.dims(), Vec::<usize>::new());
+    let result = problem.evaluate(&[]);
+    assert!(result.is_valid());
+    assert_eq!(result.unwrap(), 0);
+}