polish interfaces

Author: GiggleLiu

src/UnitDiskMapping.jl

@@ -4,7 +4,7 @@ module UnitDiskMapping
 
 using Graphs
 
-export UGrid, apply_crossing_gadgets!, apply_gadget!, embed_graph
+export UGrid, apply_crossing_gadgets!, apply_simplifier_gadgets!, apply_gadget!, embed_graph
 export unapply_gadgets!, unmatch
 export Pattern, Corner, Turn, Cross, source_graph, mapped_graph, TruncatedTurn
 export mapped_entry_to_compact, source_entry_to_configs, map_config_back, mis_overhead

src/mapping.jl

@@ -79,13 +79,11 @@ function apply_crossing_gadgets!(ug::UGrid, ruleset=crossing_ruleset)
     n = length(ug.lines)
     for j=1:n  # start from 0 because there can be one empty padding column/row.
         for i=1:n
-            matched = false
             for pattern in ruleset
                 x, y = crossat(ug, i, j) .- cross_location(pattern) .+ (1,1)
                 if match(pattern, ug.content, x, y)
                     apply_gadget!(pattern, ug.content, x, y)
                     push!(tape, (pattern, x, y))
-                    matched = true
                     break
                 end
             end
@@ -94,6 +92,21 @@ function apply_crossing_gadgets!(ug::UGrid, ruleset=crossing_ruleset)
     return ug, tape
 end
 
+function apply_simplifier_gadgets!(ug::UGrid; ruleset, nrepeat::Int=10)
+    tape = Tuple{Pattern,Int,Int}[]
+    for _ in 1:nrepeat, pattern in ruleset
+        for j=0:size(ug.content, 1)  # start from 0 because there can be one empty padding column/row.
+            for i=0:size(ug.content, 2)
+                if match(pattern, ug.content, i, j)
+                    apply_gadget!(pattern, ug.content, i, j)
+                    push!(tape, (pattern, i, j))
+                end
+            end
+        end
+    end
+    return ug, tape
+end
+
 function unapply_gadgets!(ug::UGrid, tape, configurations)
     for (pattern, i, j) in Base.Iterators.reverse(tape)
         @assert unmatch(pattern, ug.content, i, j)
@@ -294,4 +307,34 @@ function mis_overhead_copylines(ug::UGrid)
         @assert length(locs) % 2 == 1
         length(locs) ÷ 2
     end
-end
+end
+
+##### Interfaces ######
+export MappingResult, map_graph, map_configs_back
+
+struct MappingResult
+    grid_graph::UGrid
+    mapping_history::Vector{Tuple{Pattern,Int,Int}}
+    mis_overhead::Int
+end
+
+"""
+    map_graph(g::SimpleGraph; ruleset=[...])
+
+Map a graph to a unit disk grid graph that being "equivalent" to the original graph.
+Here "equivalent" means a maximum independent set in the grid graph can be mapped back to
+a maximum independent set of the original graph in polynomial time.
+
+Returns a `MappingResult` instance.
+"""
+function map_graph(g::SimpleGraph; ruleset=[RotatedGadget(DanglingLeg(), n) for n=0:3])
+    ug = embed_graph(g)
+    mis_overhead0 = mis_overhead_copylines(ug)
+    ug, tape = apply_crossing_gadgets!(ug)
+    ug, tape2 = apply_simplifier_gadgets!(ug; ruleset=ruleset)
+    mis_overhead1 = sum(x->mis_overhead(x[1]), tape)
+    mis_overhead2 = sum(x->mis_overhead(x[1]), tape2)
+    return MappingResult(ug, vcat(tape, tape2) , mis_overhead0 + mis_overhead1 + mis_overhead2)
+end
+
+map_configs_back(r::MappingResult, configs::AbstractVector) = unapply_gadgets!(copy(r.grid_graph), r.mapping_history, copy.(configs))[2]

src/simplifiers.jl

@@ -11,6 +11,7 @@ export @gg
 """
 abstract type SimplifyPattern <: Pattern end
 iscon(s::SimplifyPattern) = false
+cross_location(s::SimplifyPattern) = size(s) .÷ 2
 function source_locations end
 function mapped_locations end
 function mapped_graph(p::SimplifyPattern)
@@ -65,6 +66,9 @@ macro gg(expr)
     end
 end
 
+# # How to add a new simplification rule
+# 1. specify a gadget like the following. Use either `o` and `●` to specify a vertex,
+# either `.` or `⋅` to specify a placeholder.
 @gg DanglingLeg =
     """
     ⋅ ⋅ ⋅ 
@@ -76,4 +80,7 @@ end
     ⋅ ⋅ ⋅ 
     ⋅ ⋅ ⋅ 
     ⋅ ● ⋅
-    """
+    """
+
+# 2. run the script `project/createmap` to generate `mis_overhead` and other informations required
+# for mapping back. (Note: will overwrite the source file `src/extracting_results.jl`)

test/mapping.jl

@@ -36,22 +36,47 @@ end
         ug = embed_graph(g)
         mis_overhead0 = mis_overhead_copylines(ug)
         ug2, tape = apply_crossing_gadgets!(copy(ug))
+        ug3, tape2 = apply_simplifier_gadgets!(copy(ug2); ruleset=[RotatedGadget(UnitDiskMapping.DanglingLeg(), n) for n=0:3])
         mis_overhead1 = sum(x->mis_overhead(x[1]), tape)
-        missize_map = solve(Independence(SimpleGraph(ug2)), "size max"; optimizer=TreeSA(ntrials=1, niters=10), simplifier=MergeGreedy())[].n
+        mis_overhead2 = sum(x->mis_overhead(x[1]), tape2)
+        @show mis_overhead2
+        gp = Independence(SimpleGraph(ug3); optimizer=TreeSA(ntrials=1, niters=10), simplifier=MergeGreedy())
+        missize_map = solve(gp, "size max")[].n
         missize = solve(Independence(g), "size max")[].n
-        @test mis_overhead0 + mis_overhead1 + missize == missize_map
-        misconfig = solve(Independence(SimpleGraph(ug2)), "config max"; optimizer=TreeSA(ntrials=1, niters=10), simplifier=MergeGreedy())[].c
-        c = zeros(Int, size(ug2.content))
-        for (i, loc) in enumerate(findall(!iszero, ug2.content))
+        @test mis_overhead0 + mis_overhead1 + mis_overhead2 + missize == missize_map
+        misconfig = solve(gp, "config max")[].c
+        c = zeros(Int, size(ug3.content))
+        for (i, loc) in enumerate(findall(!iszero, ug3.content))
             c[loc] = misconfig.data[i]
         end
         @test all(ci->UnitDiskMapping.safe_get(c, ci.I...)==0 || (UnitDiskMapping.safe_get(c, ci.I[1], ci.I[2]+1) == 0 && UnitDiskMapping.safe_get(c, ci.I[1]+1, ci.I[2]) == 0 &&
             UnitDiskMapping.safe_get(c, ci.I[1]-1, ci.I[2]) == 0 && UnitDiskMapping.safe_get(c, ci.I[1], ci.I[2]-1) == 0 &&
             UnitDiskMapping.safe_get(c, ci.I[1]-1, ci.I[2]-1) == 0 && UnitDiskMapping.safe_get(c, ci.I[1]-1, ci.I[2]+1) == 0 &&
             UnitDiskMapping.safe_get(c, ci.I[1]+1, ci.I[2]-1) == 0 && UnitDiskMapping.safe_get(c, ci.I[1]+1, ci.I[2]+1) == 0
         ), CartesianIndices((55, 55)))
-        res, cs = unapply_gadgets!(copy(ug2), tape, [copy(c)])
+        res, cs = unapply_gadgets!(copy(ug3), [tape..., tape2...], [copy(c)])
         @test count(isone, cs[1]) == missize
         @test is_independent_set(g, cs[1])
     end
+end
+
+@testset "interface" begin
+    g = smallgraph(:petersen)
+    res = map_graph(g)
+
+    # checking size
+    gp = Independence(SimpleGraph(res.grid_graph); optimizer=TreeSA(ntrials=1, niters=10), simplifier=MergeGreedy())
+    missize_map = solve(gp, "size max")[].n
+    missize = solve(Independence(g), "size max")[].n
+    @test res.mis_overhead + missize == missize_map
+
+    # checking mapping back
+    misconfig = solve(gp, "config max")[].c
+    c = zeros(Int, size(res.grid_graph.content))
+    for (i, loc) in enumerate(findall(!iszero, res.grid_graph.content))
+        c[loc] = misconfig.data[i]
+    end
+    original_configs = map_configs_back(res, [c])
+    @test count(isone, original_configs[1]) == missize
+    @test is_independent_set(g, original_configs[1])
 end