Add BicliqueCover → BMF inverse; drop dominated BicliqueCover → ILP

With exact BMF and sub-biclique BicliqueCover now both in place, the two
models are isomorphic up to a layout transpose. Add the inverse reduction
so the graph is bidirectional, factor the shared transpose into helpers,
and remove the direct BicliqueCover → ILP rule that is strictly dominated
by the two-hop path through BMF.

- `src/rules/bmf_bicliquecover.rs` now exposes `config_bc_to_bmf` and
  `config_bmf_to_bc`. The forward reduction's `extract_solution` calls
  the former; the new inverse reduction's `extract_solution` calls the
  latter. Two helpers, one per direction — same transpose logic, no
  duplication.
- `src/rules/bicliquecover_bmf.rs` (new) reduces `BicliqueCover(G, k)` to
  `BMF(A_G, k)` by reading off the biadjacency matrix of `G`. Overhead:
  `rows = cols = num_vertices` (loose bound, m ≤ m+n and n ≤ m+n),
  `rank = rank`.
- The direct `BicliqueCover → ILP` rule (`bicliquecover_ilp.rs` and its
  unit tests) is removed. Path search automatically resolves
  `pred path BicliqueCover ILP` to the dominating two-hop path
  `BicliqueCover → BMF → ILP`, which has the cleaner equality-constrained
  BMF → ILP formulation.
- Paper: drop the `reduction-rule("BicliqueCover", "ILP")` entry; keep
  the new `reduction-rule("BicliqueCover", "BMF")` alongside the forward
  rule.
- New unit tests cover the inverse reduction (structure, closed-loop on
  K_{2,2} at rank 1 and identity biadjacency at rank 2, infeasibility at
  rank 1) plus a roundtrip test pinning `config_bc_to_bmf ∘ config_bmf_to_bc
  = id`.

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

Author: GiggleLiu

docs/paper/reductions.typ

@@ -14457,25 +14457,6 @@ The following reductions to Integer Linear Programming are straightforward formu
   _Solution extraction._ Output the concatenated left/right binary selection vector.
 ]
 
-#reduction-rule("BicliqueCover", "ILP")[
-  Use $k$ candidate bicliques, assign vertices to any of them, force every graph edge to be covered by some common biclique, and minimize the total membership size.
-][
-  _Construction._ Variables: binary $x_(l,b)$ for left vertices, binary $y_(r,b)$ for right vertices, and binary $z_((l,r),b)$ linearizing $x_(l,b) y_(r,b)$. The ILP is:
-  $
-    min quad & sum_(l,b) x_(l,b) + sum_(r,b) y_(r,b) \
-    "subject to" quad & z_((l,r),b) <= x_(l,b) quad forall l, r, b \
-    & z_((l,r),b) <= y_(r,b) quad forall l, r, b \
-    & z_((l,r),b) >= x_(l,b) + y_(r,b) - 1 quad forall l, r, b \
-    & sum_b z_((l,r),b) >= 1 quad forall (l, r) in E \
-    & x_(l,b) + y_(r,b) <= 1 quad forall (l, r) in.not E, b \
-    & x_(l,b), y_(r,b), z_((l,r),b) in {0, 1}.
-  $
-
-  _Correctness._ ($arrow.r.double$) Any valid $k$-biclique cover assigns each covered edge to a biclique containing both endpoints, with objective equal to the total biclique size. ($arrow.l.double$) Any feasible ILP solution defines $k$ complete bipartite subgraphs whose union covers every edge, and the objective is exactly the source objective.
-
-  _Solution extraction._ Output the flattened vertex-by-biclique membership bits and discard the coverage auxiliaries.
-]
-
 #reduction-rule("BiconnectivityAugmentation", "ILP")[
   Select candidate edges under the budget and, for every deleted vertex, certify that the remaining augmented graph stays connected by a flow witness.
 ][
@@ -14668,6 +14649,16 @@ The following reductions to Integer Linear Programming are straightforward formu
   _Solution extraction._ Given a BicliqueCover witness (vertex-major, $"cfg"_("BC")[v k + r] in {0, 1}$), set $B_(i,r) = "cfg"_("BC")[i k + r]$ and $C_(r,j) = "cfg"_("BC")[(m + j) k + r]$. The left half is a direct copy; the right half transposes from vertex-major to biclique-row-major.
 ]
 
+#reduction-rule("BicliqueCover", "BMF")[
+  The inverse of the matrix-to-graph map: read off the biadjacency matrix $A_G in {0,1}^(|L| times |R|)$ of the bipartite graph $G$ and reuse the same rank $k$.
+][
+  _Construction._ Given an instance $(G, k)$ of BicliqueCover, emit the BMF instance $(A_G, k)$ where $A_G[i][j] = 1$ iff $(i, j) in E(G)$. Source and target live in the same variable space, with the layout permutation described below.
+
+  _Correctness._ Symmetric to the forward rule: the same Monson–Pullman–Rees equivalence (sub-bicliques of $G$ $<->$ rank-1 factors of $A_G$) holds in both directions, and the two objectives — total vertex memberships and $|B|_1 + |C|_1$ — agree by construction.
+
+  _Solution extraction._ Inverse transpose of the forward map: given a BMF witness (B row-major followed by C row-major), set $"cfg"_("BC")[i k + r] = B_(i,r)$ for left vertices and $"cfg"_("BC")[(m + j) k + r] = C_(r,j)$ for right vertices.
+]
+
 #reduction-rule("ConsecutiveBlockMinimization", "ILP")[
   Permute the columns with a one-hot assignment and count row-wise block starts by detecting each 0-to-1 transition after permutation.
 ][

src/rules/bicliquecover_bmf.rs

@@ -0,0 +1,95 @@
+//! Reduction from BicliqueCover to BMF (exact Boolean Matrix Factorization).
+//!
+//! Inverse of [`crate::rules::bmf_bicliquecover`]: a bipartite graph
+//! `G = (L, R, E)` is encoded by its `|L| × |R|` biadjacency matrix
+//! `A_G` with `A_G[i][j] = 1` iff `(i, j) ∈ E`. Under the classical
+//! sub-biclique semantics, a biclique cover of `G` by `k` sub-bicliques
+//! is exactly an exact rank-`k` Boolean factorization of `A_G`, and the
+//! total biclique size equals `|B|_1 + |C|_1`.
+//!
+//! Layout mapping is the inverse transpose from the forward reduction —
+//! the shared helpers [`super::bmf_bicliquecover::config_bmf_to_bc`] and
+//! `config_bc_to_bmf` live in the sibling module.
+
+use crate::models::algebraic::BMF;
+use crate::models::graph::BicliqueCover;
+use crate::reduction;
+use crate::rules::bmf_bicliquecover::config_bmf_to_bc;
+use crate::rules::traits::{ReduceTo, ReductionResult};
+
+/// Result of reducing BicliqueCover to BMF.
+#[derive(Debug, Clone)]
+pub struct ReductionBicliqueCoverToBMF {
+    target: BMF,
+    m: usize,
+    n: usize,
+    k: usize,
+}
+
+impl ReductionResult for ReductionBicliqueCoverToBMF {
+    type Source = BicliqueCover;
+    type Target = BMF;
+
+    fn target_problem(&self) -> &BMF {
+        &self.target
+    }
+
+    /// Map a BMF config (B row-major, C row-major) to a BicliqueCover
+    /// config (vertex-major) via the inverse transpose.
+    fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
+        config_bmf_to_bc(target_solution, self.m, self.n, self.k)
+    }
+}
+
+#[reduction(
+    overhead = {
+        rows = "num_vertices",
+        cols = "num_vertices",
+        rank = "rank",
+    }
+)]
+impl ReduceTo<BMF> for BicliqueCover {
+    type Result = ReductionBicliqueCoverToBMF;
+
+    fn reduce_to(&self) -> Self::Result {
+        let m = self.left_size();
+        let n = self.right_size();
+        let k = self.k();
+        let mut matrix = vec![vec![false; n]; m];
+        for &(i, j) in self.graph().left_edges() {
+            matrix[i][j] = true;
+        }
+        let target = BMF::new(matrix, k);
+        ReductionBicliqueCoverToBMF { target, m, n, k }
+    }
+}
+
+#[cfg(feature = "example-db")]
+pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::RuleExampleSpec> {
+    use crate::export::SolutionPair;
+    use crate::topology::BipartiteGraph;
+
+    vec![crate::example_db::specs::RuleExampleSpec {
+        id: "bicliquecover_to_bmf",
+        build: || {
+            // Single K_{2,2} biclique at rank 1 — matches the forward example.
+            let source = BicliqueCover::new(
+                BipartiteGraph::new(2, 2, vec![(0, 0), (0, 1), (1, 0), (1, 1)]),
+                1,
+            );
+            crate::example_db::specs::rule_example_with_witness::<_, BMF>(
+                source,
+                SolutionPair {
+                    // BicliqueCover (vertex-major, k=1): all 4 vertices in biclique 0
+                    source_config: vec![1, 1, 1, 1],
+                    // BMF (B row-major then C row-major): B=[[1],[1]], C=[[1,1]]
+                    target_config: vec![1, 1, 1, 1],
+                },
+            )
+        },
+    }]
+}
+
+#[cfg(test)]
+#[path = "../unit_tests/rules/bicliquecover_bmf.rs"]
+mod tests;

src/rules/bicliquecover_ilp.rs

@@ -20,6 +20,43 @@ use crate::reduction;
 use crate::rules::traits::{ReduceTo, ReductionResult};
 use crate::topology::BipartiteGraph;
 
+/// Convert a BicliqueCover config (vertex-major: index `v*k + b`) to a BMF
+/// config (B row-major at `[0, m*k)` then C row-major at `[m*k, m*k + k*n)`).
+///
+/// The left half copies unchanged; the right half transposes from
+/// vertex-major `(m+j)*k + l` to biclique-row-major `m*k + l*n + j`.
+pub(crate) fn config_bc_to_bmf(bc: &[usize], m: usize, n: usize, k: usize) -> Vec<usize> {
+    let mut bmf = vec![0usize; m * k + k * n];
+    for i in 0..m {
+        for l in 0..k {
+            bmf[i * k + l] = bc[i * k + l];
+        }
+    }
+    for l in 0..k {
+        for j in 0..n {
+            bmf[m * k + l * n + j] = bc[(m + j) * k + l];
+        }
+    }
+    bmf
+}
+
+/// Inverse of [`config_bc_to_bmf`]: BMF config (B row-major then C row-major)
+/// to BicliqueCover config (vertex-major).
+pub(crate) fn config_bmf_to_bc(bmf: &[usize], m: usize, n: usize, k: usize) -> Vec<usize> {
+    let mut bc = vec![0usize; (m + n) * k];
+    for i in 0..m {
+        for l in 0..k {
+            bc[i * k + l] = bmf[i * k + l];
+        }
+    }
+    for l in 0..k {
+        for j in 0..n {
+            bc[(m + j) * k + l] = bmf[m * k + l * n + j];
+        }
+    }
+    bc
+}
+
 /// Result of reducing BMF to BicliqueCover.
 #[derive(Debug, Clone)]
 pub struct ReductionBMFToBicliqueCover {
@@ -39,26 +76,7 @@ impl ReductionResult for ReductionBMFToBicliqueCover {
 
     /// Map a BicliqueCover config (vertex-major) back to a BMF config (B row-major, then C row-major).
     fn extract_solution(&self, target_solution: &[usize]) -> Vec<usize> {
-        let m = self.m;
-        let n = self.n;
-        let k = self.k;
-        let mut source = vec![0usize; m * k + k * n];
-        // Left half: identical layout — BicliqueCover left vertex i, biclique l at index i*k + l
-        // matches BMF B[i][l] at index i*k + l.
-        for i in 0..m {
-            for l in 0..k {
-                source[i * k + l] = target_solution[i * k + l];
-            }
-        }
-        // Right half: transpose from vertex-major to biclique-row-major.
-        // BicliqueCover right vertex j, biclique l at index (m + j)*k + l.
-        // BMF C[l][j] at index m*k + l*n + j.
-        for l in 0..k {
-            for j in 0..n {
-                source[m * k + l * n + j] = target_solution[(m + j) * k + l];
-            }
-        }
-        source
+        config_bc_to_bmf(target_solution, self.m, self.n, self.k)
     }
 }
 

src/rules/bmf_bicliquecover.rs

@@ -8,6 +8,7 @@ pub use cost::{
 };
 pub use registry::{EdgeCapabilities, ReductionEntry, ReductionOverhead};
 
+pub(crate) mod bicliquecover_bmf;
 pub(crate) mod bmf_bicliquecover;
 pub(crate) mod circuit_sat;
 pub(crate) mod circuit_spinglass;
@@ -141,8 +142,6 @@ pub(crate) mod acyclicpartition_ilp;
 #[cfg(feature = "ilp-solver")]
 pub(crate) mod balancedcompletebipartitesubgraph_ilp;
 #[cfg(feature = "ilp-solver")]
-pub(crate) mod bicliquecover_ilp;
-#[cfg(feature = "ilp-solver")]
 pub(crate) mod biconnectivityaugmentation_ilp;
 #[cfg(feature = "ilp-solver")]
 pub(crate) mod binpacking_ilp;
@@ -380,6 +379,7 @@ pub use traits::{
 #[cfg(feature = "example-db")]
 pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::RuleExampleSpec> {
     let mut specs = Vec::new();
+    specs.extend(bicliquecover_bmf::canonical_rule_example_specs());
     specs.extend(bmf_bicliquecover::canonical_rule_example_specs());
     specs.extend(circuit_sat::canonical_rule_example_specs());
     specs.extend(circuit_spinglass::canonical_rule_example_specs());
@@ -509,7 +509,6 @@ pub(crate) fn canonical_rule_example_specs() -> Vec<crate::example_db::specs::Ru
     {
         specs.extend(acyclicpartition_ilp::canonical_rule_example_specs());
         specs.extend(balancedcompletebipartitesubgraph_ilp::canonical_rule_example_specs());
-        specs.extend(bicliquecover_ilp::canonical_rule_example_specs());
         specs.extend(biconnectivityaugmentation_ilp::canonical_rule_example_specs());
         specs.extend(binpacking_ilp::canonical_rule_example_specs());
         specs.extend(bmf_ilp::canonical_rule_example_specs());