New reduction rule: BinaryMatrixFactorization to BicliqueCover

src/ProblemReductions.jl

@@ -48,6 +48,7 @@ export ReductionIndependentSetToSetPacking, ReductionSetPackingToIndependentSet
 export ReductionSATToCircuit
 export ReductionIndependentSetToVertexCovering
 export ReductionMatchingToSetPacking
+export ReductionBMFToBicliqueCover
 
 # reduction path
 export ReductionGraph, reduction_graph, reduction_paths, ConcatenatedReduction

src/models/BMF.jl

@@ -18,7 +18,7 @@ The Boolean Matrix Factorization (BMF) problem is defined on a binary matrix A i
 struct BinaryMatrixFactorization<: AbstractProblem
     A::BitMatrix
     k::Int
-    function BinaryMatrixFactorization(A::BitMatrix, k::Int) where K
+    function BinaryMatrixFactorization(A::BitMatrix, k::Int)
         new(A, k)
     end
 end

src/models/BicliqueCover.jl

@@ -35,7 +35,7 @@
 # Variables Interface
 # each vertex is assigned to a biclique, with k bicliques, variables(c::BicliqueCover) = fill(1,c.k * nv(c.graph)) 
 num_variables(c::BicliqueCover) = nv(c.graph) * c.k
-num_flavors(c::BicliqueCover) = 2
+num_flavors(::Type{BicliqueCover{Int64}}) = 2
 
 # constraints interface
 function constraints(c::BicliqueCover)

src/rules/BMF_BicliqueCover.jl

@@ -0,0 +1,46 @@
+"""
+$TYPEDEF
+
+The reduction result from BinaryMatrixFactorization to BicliqueCover.
+
+### Fields
+- `bicliquecover`: The BicliqueCover problem.
+- `k`: The number of bicliques.
+"""
+struct ReductionBMFToBicliqueCover{Int64} <: AbstractReductionResult
+    bicliquecover::BicliqueCover{Int64}
+    k::Int64
+end
+Base.:(==)(a::ReductionBMFToBicliqueCover, b::ReductionBMFToBicliqueCover) = a.bicliquecover == b.bicliquecover && a.k == b.k
+target_problem(res::ReductionBMFToBicliqueCover) = res.bicliquecover
+
+function reduceto(::Type{BicliqueCover}, bmf::BinaryMatrixFactorization)
+    k = bmf.k
+    A = Int.(bmf.A)
+    return ReductionBMFToBicliqueCover(ProblemReductions.biclique_cover_from_matrix(A, k), k)
+end
+
+function extract_solution(res::ReductionBMFToBicliqueCover{Int64}, solution::Vector{Vector{Int64}})
+    len_part1 = length(res.bicliquecover.part1)
+    len_part2 = nv(res.bicliquecover.graph) - len_part1
+    B = falses((len_part1,res.k))
+    C = falses((res.k,len_part1))
+    # each iteration, we update the a-th column of B and the a-th row of C
+    for a in range(1,res.k)
+        for i in range(1,len_part1)
+            if solution[a][i] == 1
+                B[i,a] = true
+            end
+        end
+        for j in range(1,len_part2)
+            if solution[a][j+len_part1] == 1
+                C[a,j] = true
+            end
+        end
+    end
+    return (B,C)
+end
+
+function extract_multiple_solutions(res::ReductionBMFToBicliqueCover{Int64}, solution_set::Vector{Vector{Vector{Int64}}})
+    return unique(extract_solution.(Ref(res), solution_set))
+end

src/rules/rules.jl

@@ -88,4 +88,5 @@ include("sat_dominatingset.jl")
 include("independentset_setpacking.jl")
 include("circuit_sat.jl")
 include("vertexcovering_independentset.jl")
-include("matching_setpacking.jl")
+include("matching_setpacking.jl")
+include("BMF_BicliqueCover.jl")

test/models/BicliqueCover.jl

@@ -10,6 +10,7 @@ using Test, ProblemReductions, Graphs
     # variable and weight interfaces
     @test num_variables(bc) == 12
     @test num_flavors(bc) == 2
+    @test num_flavors(BicliqueCover{Int64}) == 2
     @test problem_size(bc) == (num_vertices=6, num_edges=5, k=2)
     bc_matrix = ProblemReductions.biclique_cover_from_matrix([1 1 0;1 1 0;0 0 1],2)
     @test bc_matrix == bc

test/rules/BMF_BicliqueCover.jl

@@ -0,0 +1,17 @@
+using Test, ProblemReductions, Graphs
+
+@testset "BMF_BicliqueCover" begin
+    A = [1 0 ; 1 1]
+    A = BitMatrix(A)
+    bmf1 = BinaryMatrixFactorization(A, 2)
+    bc1 = ProblemReductions.biclique_cover_from_matrix(Int.(A), 2)
+    res = reduceto(BicliqueCover, bmf1)
+    res1 = ReductionBMFToBicliqueCover(bc1,2)
+    @test res == res1
+    @test res.k == 2
+    @test res.bicliquecover == bc1
+    @test res.bicliquecover.part1 == [i for i in 1:size(A,1)]
+    @test target_problem(res) == bc1
+    @test extract_solution(res,[[1,1,1,0],[0,1,0,1]]) == ([true false ; true true], [true false ; false true])
+    @test extract_multiple_solutions(res,[[[1,1,1,0],[0,1,0,1]]]) == [([true false ; true true], [true false ; false true])]
+end

test/rules/rules.jl

@@ -52,6 +52,10 @@ end
     include("matching_setpacking.jl")
 end
 
+@testset "BMF_BicliqueCover" begin
+    include("BMF_BicliqueCover.jl")
+end
+
 @testset "rules" begin
     circuit = CircuitSAT(@circuit begin
         x = a ∨ ¬b