port to ProblemReductions.jl, tests all pass

src/Core.jl

@@ -76,6 +76,12 @@ function Graphs.SimpleGraph(grid::GridGraph{Node{ONE}})
     return unit_disk_graph(getfield.(grid.nodes, :loc), grid.radius)
 end
 coordinates(grid::GridGraph) = getfield.(grid.nodes, :loc)
+function Graphs.neighbors(g::GridGraph, i::Int)
+    [j for j in 1:nv(g) if i != j && distance(g.nodes[i], g.nodes[j]) <= g.radius]
+end
+distance(n1::Node, n2::Node) = sqrt(sum(abs2, n1.loc .- n2.loc))
+Graphs.nv(g::GridGraph) = length(g.nodes)
+Graphs.vertices(g::GridGraph) = 1:nv(g)
 
 # printing function for Grid graphs
 function print_grid(io::IO, grid::GridGraph{Node{WT}}; show_weight=false) where WT

src/multiplier.jl

@@ -97,7 +97,7 @@ function map_factoring(M::Int, N::Int)
         [pinloc(1, j, 1) for j=1:N]...,
         [pinloc(i, N, 4) for i=1:M]...,
     ]
-    return FactoringResult(gg, pp, pq, pm, p0)
+    return FactoringResult(gg, pq, pp, pm, p0)
 end
 
 struct FactoringResult{NT}
@@ -131,7 +131,7 @@ function solve_factoring(missolver, mres::FactoringResult, target::Int)
     return map_config_back(mres, cfg)
 end
 
-function set_target(g::SimpleGraph, pins::AbstractVector, target::Int)
+function set_target(g, pins::AbstractVector, target::Int)
     vs = collect(vertices(g))
     for (i, p) in enumerate(pins)
         bitval = (target >> (i-1)) & 1

src/reduceto.jl

@@ -1,26 +1,60 @@
-struct IndependentSetKSGResult{NT, VT} <: ProblemReductions.AbstractReductionResult
+struct IndependentSetToKSG{NT, VT} <: ProblemReductions.AbstractReductionResult
     mapres::MappingResult{NT}
     weights::VT
 end
+function _to_gridgraph(g::UnitDiskMapping.GridGraph)
+    return ProblemReductions.GridGraph(g.size, getfield.(g.nodes, :loc), g.radius)
+end
+function _extract_weights(g::UnitDiskMapping.GridGraph{<:WeightedNode})
+    getfield.(g.nodes, :weight)
+end
 
-# unweighted reduction
+###### unweighted reduction
 function ProblemReductions.reduceto(::Type{ProblemReductions.IndependentSet{ProblemReductions.GridGraph, Int, ProblemReductions.UnitWeight}}, problem::ProblemReductions.IndependentSet{GT, Int, ProblemReductions.UnitWeight} where GT<:SimpleGraph)
-    return IndependentSetKSGResult(map_graph(UnWeighted(), problem.graph), problem.weights)
+    return IndependentSetToKSG(map_graph(UnWeighted(), problem.graph), problem.weights)
 end
 
-function ProblemReductions.reduceto(::Type{ProblemReductions.IndependentSet{ProblemReductions.GridGraph, T, Vector{T}}} where T, problem::ProblemReductions.IndependentSet{GT} where GT<:SimpleGraph)
-    return IndependentSetKSGResult(map_graph(Weighted(), problem.graph), problem.weights)
+function ProblemReductions.target_problem(res::IndependentSetToKSG{<:UnWeightedNode})
+    return ProblemReductions.IndependentSet(_to_gridgraph(res.mapres.grid_graph))
+end
+function ProblemReductions.extract_solution(res::IndependentSetToKSG, sol)
+    return map_config_back(res.mapres, sol)
 end
 
-function ProblemReductions.target_problem(res::IndependentSetKSGResult{<:UnWeightedNode})
-    return ProblemReductions.IndependentSet(SimpleGraph(res.mapres.grid_graph))
+###### Weighted reduction
+# TODO: rescale the weights to avoid errors
+function ProblemReductions.reduceto(::Type{ProblemReductions.IndependentSet{ProblemReductions.GridGraph, T, Vector{T}}} where T, problem::ProblemReductions.IndependentSet{GT} where GT<:SimpleGraph)
+    return IndependentSetToKSG(map_graph(Weighted(), problem.graph), problem.weights)
 end
-function ProblemReductions.target_problem(res::IndependentSetKSGResult{<:WeightedNode})
-    graph, _ = graph_and_weights(res.mapres.grid_graph)
+function ProblemReductions.target_problem(res::IndependentSetToKSG{<:WeightedNode})
+    graph = _to_gridgraph(res.mapres.grid_graph)
     weights = UnitDiskMapping.map_weights(res.mapres, res.weights)
     return ProblemReductions.IndependentSet(graph, weights)
 end
 
-function ProblemReductions.extract_solution(res::IndependentSetKSGResult, sol)
-    return map_config_back(res.mapres, sol)
+###### Factoring ######
+struct FactoringToIndependentSet{NT} <: ProblemReductions.AbstractReductionResult
+    mapres::FactoringResult{NT}
+    raw_graph::ProblemReductions.GridGraph
+    raw_weight::Vector{Int}
+    vmap::Vector{Int}
+    problem::ProblemReductions.IndependentSet{ProblemReductions.GridGraph, Int, Vector{Int}}
+end
+function ProblemReductions.reduceto(::Type{ProblemReductions.IndependentSet{ProblemReductions.GridGraph, T, Vector{T}}} where T, problem::ProblemReductions.Factoring)
+    mres = map_factoring(problem.m, problem.n)
+    g = _to_gridgraph(mres.grid_graph)
+    ws = getfield.(mres.grid_graph.nodes, :weight)
+    mg, vmap = set_target(g, [mres.pins_zeros..., mres.pins_output...], problem.input << length(mres.pins_zeros))
+    return FactoringToIndependentSet(mres, g, ws, vmap, ProblemReductions.IndependentSet(mg, ws[vmap]))
+end
+
+function ProblemReductions.target_problem(res::FactoringToIndependentSet)
+    return res.problem
+end
+
+function ProblemReductions.extract_solution(res::FactoringToIndependentSet, sol)
+    cfg = zeros(Int, nv(res.raw_graph))
+    cfg[res.vmap] .= sol
+    i1, i2 = map_config_back(res.mapres, cfg)
+    return vcat([i1>>(k-1) & 1 for k=1:length(res.mapres.pins_input1)], [i2>>(k-1) & 1 for k=1:length(res.mapres.pins_input2)])
 end

test/Core.jl

@@ -0,0 +1,15 @@
+using Test, UnitDiskMapping, Graphs
+
+@testset "GridGraph" begin
+    grid = GridGraph((5, 5), [Node(2, 3), Node(2, 4), Node(5, 5)], 1.2)
+    g = SimpleGraph(grid)
+    @test ne(g) == 1
+    @test vertices(grid) == vertices(g)
+    @test neighbors(grid, 2) == neighbors(g, 2)
+
+    grid = GridGraph((5, 5), [Node(2, 3), Node(2, 4), Node(5, 5)], 4.0)
+    g = SimpleGraph(grid)
+    @test ne(g) == 3
+    @test vertices(grid) == vertices(g)
+    @test neighbors(grid, 2) == neighbors(g, 2)
+end

test/reduceto.jl

@@ -1,26 +1,31 @@
-using Test, UnitDiskMapping, ProblemReductions, Graphs
+using Test, UnitDiskMapping, Graphs, GenericTensorNetworks
+import ProblemReductions
 
 @testset "rules" begin
     graph = complete_graph(3)  # triangle
-    is = IndependentSet(graph)
-    wis = IndependentSet(graph, rand(nv(graph)) .* 0.2)
+    fact = ProblemReductions.Factoring(2, 1, 2)
+    is = ProblemReductions.IndependentSet(graph)
+    wis = ProblemReductions.IndependentSet(graph, rand(nv(graph)) .* 0.2)
     for (source, target_type) in [
             # please add more tests here
-            is => IndependentSet{ProblemReductions.GridGraph, Int, UnitWeight},
-            wis => IndependentSet{ProblemReductions.GridGraph, Int, Vector{Int}},
+            is => ProblemReductions.IndependentSet{ProblemReductions.GridGraph, Int, ProblemReductions.UnitWeight},
+            wis => ProblemReductions.IndependentSet{ProblemReductions.GridGraph, Float64, Vector{Float64}},
+            fact => ProblemReductions.IndependentSet{ProblemReductions.GridGraph, Int, Vector{Int}},
         ]
         @info "Testing reduction from $(typeof(source)) to $(target_type)"
         # directly solve
-        best_source = findbest(source, BruteForce())
+        best_source = ProblemReductions.findbest(source, ProblemReductions.BruteForce())
 
         # reduce and solve
-        result = reduceto(target_type, source)
-        target = target_problem(result)
-        best_target = findbest(target, BruteForce())
+        result = ProblemReductions.reduceto(target_type, source)
+        target = ProblemReductions.target_problem(result)
+        @test target isa target_type
+        #best_target = findbest(target, BruteForce())
+        best_target = GenericTensorNetworks.solve(GenericTensorNetwork(GenericTensorNetworks.IndependentSet(SimpleGraph(target.graph), collect(target.weights))), ConfigsMax())[].c.data
 
         # extract the solution
-        best_source_extracted_single = unique( extract_solution.(Ref(result), best_target) )
-        best_source_extracted_multiple = extract_multiple_solutions(result, best_target)
+        best_source_extracted_single = unique( ProblemReductions.extract_solution.(Ref(result), best_target) )
+        best_source_extracted_multiple = ProblemReductions.extract_multiple_solutions(result, best_target)
 
         # check if the solutions are the same
         @test best_source_extracted_single ⊆ best_source

test/runtests.jl

@@ -1,6 +1,10 @@
 using UnitDiskMapping
 using Test
 
+@testset "Core" begin
+    include("Core.jl")
+end
+
 @testset "utils" begin
     include("utils.jl")
 end