print configurations

Author: GiggleLiu

README.md

@@ -33,16 +33,21 @@ For current master
 pkg> add UnitDiskMapping#master
 ```
 
-## Example
+## Example 1: Unweighted mapping
+#### Step 1: map a Petersen graph to a grid graph
 ```julia
 julia> using Graphs, UnitDiskMapping
 
 julia> g = smallgraph(:petersen)
 {10, 15} undirected simple Int64 graph
 
+# `Branching()` is an exact algorithm for finding an optimal vertex ordering
 julia> res = map_graph(g, vertex_order=Branching());
 
-julia> res.grid_graph
+julia> res.mis_overhead
+89
+
+julia> println(res.grid_graph)
 ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ 
 ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ 
 ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ● ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ● ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ● ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ 
@@ -72,7 +77,74 @@ julia> res.grid_graph
 ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ 
 ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ 
 ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ 
+```
+
+#### Step 2: solve the MIS problem on grid graph with any method you like
+In the following, we show how to solve this maximal independent set problem on grid graph with the open source package [`GraphTensorNetworks`](https://github.com/Happy-Diode/GraphTensorNetworks.jl) and map the configurations back.
+The generic tensor network approach for solving MIS works best for graphs with small tree width, it can solve this grid graph `G(V,E)` in sub-exponential time `t~2^{sqrt(|V|)}`.
+
+```julia
+julia> using GraphTensorNetworks
+
+julia> gp = Independence(SimpleGraph(res.grid_graph); optimizer=TreeSA(ntrials=1, niters=10), simplifier=MergeGreedy());
 
+julia> misconfig = solve(gp, "config max")[].c;
+
+# create a grid mask as the solution, where occupied locations are marked as value 1.
+julia> c = zeros(Int, size(res.grid_graph.content));
+
+julia> for (i, loc) in enumerate(findall(!isempty, res.grid_graph.content))
+           c[loc] = misconfig.data[i]
+       end
+
+julia> print_config(res, c)
+⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ 
+⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ 
+⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ◯ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ● ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ◯ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ 
+⋅ ⋅ ⋅ ⋅ ⋅ ● ⋅ ◯ ● ◯ ● ◯ ● ◯ ● ◯ ● ◯ ⋅ ◯ ● ◯ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ◯ ● ◯ ● ◯ ● ⋅ ● ◯ ● ⋅ ⋅ ⋅ 
+⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ◯ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ● ⋅ ⋅ ⋅ ● ⋅ ⋅ ⋅ ⋅ ● ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ◯ ⋅ ⋅ ⋅ ◯ ⋅ ⋅ 
+⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ● ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ◯ ⋅ ⋅ ⋅ ◯ ⋅ ⋅ ⋅ ◯ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ● ⋅ ⋅ ⋅ ● ⋅ ⋅ 
+⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ◯ ⋅ ⋅ ● ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ● ⋅ ⋅ ⋅ ● ⋅ ⋅ ⋅ ● ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ◯ ⋅ ⋅ ⋅ ◯ ⋅ ⋅ 
+⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ● ◯ ⋅ ◯ ● ◯ ● ◯ ● ◯ ◯ ◯ ● ◯ ◯ ◯ ● ◯ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ◯ ● ◯ ● ◯ ● ⋅ ● ⋅ 
+⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ● ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ◯ ● ◯ ⋅ ◯ ● ◯ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ◯ ⋅ ◯ ◯ ◯ ⋅ ⋅ ◯ ⋅ ⋅ 
+⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ◯ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ◯ ⋅ ⋅ ⋅ ◯ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ● ⋅ ⋅ ⋅ ● ⋅ ⋅ ⋅ ● ⋅ ⋅ 
+⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ● ⋅ ⋅ ◯ ⋅ ⋅ ⋅ ● ⋅ ⋅ ⋅ ● ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ◯ ⋅ ⋅ ⋅ ◯ ⋅ ⋅ ⋅ ◯ ⋅ ⋅ 
+⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ◯ ● ⋅ ● ◯ ◯ ◯ ◯ ◯ ◯ ◯ ◯ ◯ ● ◯ ● ◯ ● ⋅ ● ⋅ ⋅ ● ⋅ ⋅ ⋅ ● ⋅ ⋅ 
+⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ◯ ⋅ ⋅ ● ◯ ● ⋅ ● ◯ ● ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ◯ ⋅ ⋅ ⋅ ◯ ⋅ ⋅ ⋅ ◯ ⋅ ⋅ 
+⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ● ⋅ ⋅ ⋅ ◯ ⋅ ⋅ ⋅ ◯ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ● ⋅ ⋅ ⋅ ● ⋅ ⋅ ⋅ ● ⋅ ⋅ 
+⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ◯ ⋅ ⋅ ● ⋅ ⋅ ⋅ ● ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ◯ ⋅ ⋅ ⋅ ◯ ⋅ ⋅ ⋅ ◯ ⋅ ⋅ 
+⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ● ◯ ◯ ◯ ● ◯ ◯ ◯ ◯ ● ◯ ● ◯ ● ◯ ● ◯ ● ⋅ ● ⋅ ⋅ ● ⋅ ⋅ 
+⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ● ⋅ ⋅ ◯ ◯ ● ⋅ ⋅ ⋅ ⋅ ⋅ ◯ ◯ ◯ ⋅ ⋅ ◯ ⋅ ⋅ ⋅ ◯ ⋅ ⋅ 
+⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ◯ ⋅ ⋅ ⋅ ◯ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ● ⋅ ⋅ ⋅ ● ⋅ ⋅ ⋅ ● ⋅ ⋅ 
+⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ● ⋅ ⋅ ● ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ◯ ⋅ ⋅ ⋅ ◯ ⋅ ⋅ ⋅ ◯ ⋅ ⋅ 
+⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ◯ ◯ ◯ ◯ ◯ ● ◯ ● ◯ ● ◯ ● ◯ ● ◯ ● ◯ ● ⋅ ⋅ ⋅ 
+⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ● ◯ ● ⋅ ⋅ ⋅ ⋅ ⋅ ◯ ◯ ◯ ⋅ ◯ ◯ ◯ ⋅ ⋅ ⋅ ⋅ ⋅ 
+⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ◯ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ● ⋅ ⋅ ⋅ ● ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ 
+⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ● ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ◯ ⋅ ⋅ ⋅ ◯ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ 
+⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ◯ ● ◯ ● ◯ ● ⋅ ● ◯ ● ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ 
+⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ◯ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ 
+⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ 
+⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ 
+⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ 
+⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ 
+```
+
+#### Step 3: solve the MIS solution back an MIS of the source graph
+```julia
+julia> original_configs = map_configs_back(res, [c])
+1-element Vector{Vector{Int64}}:
+ [1, 0, 0, 1, 0, 0, 1, 1, 0, 0]
+
+julia> UnitDiskMapping.is_independent_set(g, original_configs[1])
+true
+```
+
+One can check this configuration with MIS size 4 is indead a maximal independent set of Petersen graph.
+Alternatively, one can use the following weighted mapping.
+
+## Example 2: Weighted mapping
+One just add a new argument `Weighted()` for the `map_graph` function in the previous example:
+```julia
 julia> w_res = map_graph(Weighted(), g, vertex_order=Branching());
 
 julia> w_res.grid_graph

src/mapping.jl

@@ -90,6 +90,35 @@ function print_ugrid(io::IO, content::AbstractMatrix)
         end
     end
 end
+export print_config
+print_config(mr::MappingResult, config::AbstractMatrix) = print_config(stdout, mr, config)
+function print_config(io::IO, mr::MappingResult, config::AbstractMatrix)
+    content = mr.grid_graph.content
+    @assert size(content) == size(config)
+    for i=1:size(content, 1)
+        for j=1:size(content, 2)
+            cell = content[i, j]
+            @assert !(cell.connected || cell.doubled)
+            if !isempty(cell)
+                if !iszero(config[i,j])
+                    print(io, "●")
+                else
+                    print(io, "◯")
+                end
+            else
+                if !iszero(config[i,j])
+                    error("configuration not valid, there is not vertex at location $((i,j)).")
+                end
+                print(io, "⋅")
+            end
+            print(io, " ")
+        end
+        if i!=size(content, 1)
+            println(io)
+        end
+    end
+end
+
 Base.copy(ug::UGrid) = UGrid(ug.lines, ug.padding, copy(ug.content))
 
 # TODO:

test/mapping.jl

@@ -110,4 +110,6 @@ end
     original_configs = map_configs_back(res, [c])
     @test count(isone, original_configs[1]) == missize
     @test is_independent_set(g, original_configs[1])
+    @test println(res.grid_graph) === nothing
+    @test print_config(res, c) === nothing
 end