Upgrade LuxorGraphPlot to v0.5 (#84)

* upgrade LuxorGraphPlot to v0.5

* update

* fix docs

* update

* update docstring

* update docs

* update

Author: GiggleLiu

Project.toml

@@ -37,7 +37,7 @@ DocStringExtensions = "0.8, 0.9"
 FFTW = "1.4"
 Graphs = "1.7"
 LinearAlgebra = "1"
-LuxorGraphPlot = "0.4"
+LuxorGraphPlot = "0.5"
 OMEinsum = "0.8"
 Polynomials = "4"
 Primes = "0.5"

docs/Project.toml

@@ -1,4 +1,5 @@
 [deps]
+CairoMakie = "13f3f980-e62b-5c42-98c6-ff1f3baf88f0"
 DocThemeIndigo = "8bac0ac5-51bf-41f9-885e-2bf1ac2bec5f"
 Documenter = "e30172f5-a6a5-5a46-863b-614d45cd2de4"
 GenericTensorNetworks = "3521c873-ad32-4bb4-b63d-f4f178f42b49"

docs/src/ref.md

@@ -99,6 +99,19 @@ ConfigSampler
 
 `GenericTensorNetworks` also exports the [`Polynomial`](https://juliamath.github.io/Polynomials.jl/stable/polynomials/polynomial/#Polynomial-2) and [`LaurentPolynomial`](https://juliamath.github.io/Polynomials.jl/stable/polynomials/polynomial/#Polynomials.LaurentPolynomial) types defined in package `Polynomials`.
 
+
+For reading the properties from the above element types, one can use the following functions.
+
+```@docs
+read_size
+read_count
+read_config
+read_size_count
+read_size_config
+```
+
+The following functions are for saving and loading configurations.
+
 ```@docs
 StaticBitVector
 StaticElementVector
@@ -136,8 +149,15 @@ MergeGreedy
 show_graph
 show_configs
 show_einsum
+show_landscape
 GraphDisplayConfig
-Layout
+AbstractLayout
+SpringLayout
+StressLayout
+SpectralLayout
+Layered
+LayeredSpringLayout
+LayeredStressLayout
 render_locs
 
 diagonal_coupled_graph

docs/src/sumproduct.md

@@ -4,6 +4,7 @@ It is a sum-product expression tree to store [`ConfigEnumerator`](@ref) in a laz
 Although it is space efficient, it is in general not easy to extract information from it due to the exponential large configuration space.
 Directed sampling is one of its most important operations, with which one can get some statistic properties from it with an intermediate effort. For example, if we want to check some property of an intermediate scale graph, one can type
 ```@repl sumproduct
+using GenericTensorNetworks
 graph = random_regular_graph(70, 3)
 problem = GenericTensorNetwork(IndependentSet(graph); optimizer=TreeSA());
 tree = solve(problem, ConfigsAll(; tree_storage=true))[]
@@ -15,11 +16,14 @@ However, this sum-product binary tree structure supports efficient and unbiased
 samples = generate_samples(tree, 1000)
 ```
 
-With these samples, one can already compute useful properties like Hamming distance (see [`hamming_distribution`](@ref)) distribution.
+With these samples, one can already compute useful properties like Hamming distance (see [`hamming_distribution`](@ref)) distribution. The following code visualizes this distribution with `CairoMakie`.
 
-```@repl sumproduct
-using UnicodePlots
-lineplot(hamming_distribution(samples, samples))
-```
-
-Here, the ``x``-axis is the Hamming distance and the ``y``-axis is the counting of pair-wise Hamming distances.
+```@example sumproduct
+using CairoMakie
+dist = hamming_distribution(samples, samples)
+# bar plot
+fig = Figure()
+ax = Axis(fig[1, 1]; xlabel="Hamming distance", ylabel="Frequency")
+barplot!(ax, 0:length(dist)-1, dist)
+fig
+```

examples/Coloring.jl

@@ -50,24 +50,26 @@ num_of_coloring = solve(problem, CountingMax())[]
 
 # ##### finding one best coloring
 single_solution = solve(problem, SingleConfigMax())[]
+read_config(single_solution)
 
-is_vertex_coloring(graph, single_solution.c.data)
+is_vertex_coloring(graph, read_config(single_solution))
 
 vertex_color_map = Dict(0=>"red", 1=>"green", 2=>"blue")
 
 show_graph(graph, locations; format=:svg, vertex_colors=[vertex_color_map[Int(c)]
-     for c in single_solution.c.data])
+     for c in read_config(single_solution)])
 
 # Let us try to solve the same issue on its line graph, a graph that generated by mapping an edge to a vertex and two edges sharing a common vertex will be connected.
 linegraph = line_graph(graph)
 
-show_graph(linegraph, [0.5 .* (locations[e.src] .+ locations[e.dst])
+show_graph(linegraph, [(locations[e.src] .+ locations[e.dst])
      for e in edges(graph)]; format=:svg)
 
 # Let us construct the tensor network and see if there are solutions.
 lineproblem = Coloring{3}(linegraph);
 
 num_of_coloring = solve(GenericTensorNetwork(lineproblem), CountingMax())[]
+read_size_count(num_of_coloring)
 
 # You will see the maximum size 28 is smaller than the number of edges in the `linegraph`,
 # meaning no solution for the 3-coloring on edges of a Petersen graph.

examples/DominatingSet.jl

@@ -68,7 +68,7 @@ counting_min_dominating_set = solve(problem, CountingMin())[]
 # ### Configuration properties
 # ##### finding minimum dominating set
 # One can enumerate all minimum dominating sets with the [`ConfigsMin`](@ref) property in the program.
-min_configs = solve(problem, ConfigsMin())[].c
+min_configs = read_config(solve(problem, ConfigsMin())[])
 
 all(c->is_dominating_set(graph, c), min_configs)
 

examples/IndependentSet.jl

@@ -65,7 +65,7 @@ maximum_independent_set_size = solve(problem, SizeMax())[]
 
 # Here [`SizeMax`](@ref) means finding the solution with maximum set size.
 # The return value has [`Tropical`](@ref) type. We can get its content by typing
-maximum_independent_set_size.n
+read_size(maximum_independent_set_size)
 
 # ### Counting properties
 # ##### Count all solutions and best several solutions
@@ -81,15 +81,15 @@ count_maximum_independent_sets = solve(problem, CountingMax())[]
 # The return value has type [`CountingTropical`](@ref), which contains two fields.
 # They are `n` being the maximum independent set size and `c` being the number of the maximum independent sets.
 
-count_maximum_independent_sets.c
+read_size_count(count_maximum_independent_sets)
 
 # Similarly, we can count independent sets of sizes ``\alpha(G)`` and ``\alpha(G)-1`` by feeding an integer positional argument to [`CountingMax`](@ref).
 count_max2_independent_sets = solve(problem, CountingMax(2))[]
 
 # The return value has type [`TruncatedPoly`](@ref), which contains two fields.
 # They are `maxorder` being the maximum independent set size and `coeffs` being the number of independent sets having sizes ``\alpha(G)-1`` and ``\alpha(G)``.
 
-count_max2_independent_sets.coeffs
+read_size_count(count_max2_independent_sets)
 
 # ##### Find the graph polynomial
 # We can count the number of independent sets at any size, which is equivalent to finding the coefficients of an independence polynomial that defined as
@@ -104,7 +104,7 @@ count_max2_independent_sets.coeffs
 independence_polynomial = solve(problem, GraphPolynomial(; method=:finitefield))[]
 
 # The return type is [`Polynomial`](https://juliamath.github.io/Polynomials.jl/stable/polynomials/polynomial/#Polynomial-2).
-independence_polynomial.coeffs
+read_size_count(independence_polynomial)
 
 # ### Configuration properties
 # ##### Find one best solution
@@ -116,7 +116,7 @@ independence_polynomial.coeffs
 max_config = solve(problem, SingleConfigMax(; bounded=false))[]
 
 # The return value has type [`CountingTropical`](@ref) with its counting field having [`ConfigSampler`](@ref) type. The `data` field of [`ConfigSampler`](@ref) is a bit string that corresponds to the solution
-single_solution = max_config.c.data
+single_solution = read_config(max_config)
 
 # This bit string should be read from left to right, with the i-th bit being 1 (0) to indicate the i-th vertex is present (absent) in the set.
 # We can visualize this MIS with the following function.
@@ -130,10 +130,10 @@ all_max_configs = solve(problem, ConfigsMax(; bounded=true))[]
 
 # The return value has type [`CountingTropical`](@ref), while its counting field having type [`ConfigEnumerator`](@ref). The `data` field of a [`ConfigEnumerator`](@ref) instance contains a vector of bit strings.
 
-all_max_configs.c.data
+_, configs_vector = read_size_config(all_max_configs)
 
 # These solutions can be visualized with the [`show_configs`](@ref) function.
-show_configs(graph, locations, reshape(collect(all_max_configs.c), 1, length(all_max_configs.c)); padding_left=20)
+show_configs(graph, locations, reshape(configs_vector, 1, :); padding_left=20)
 
 # We can use [`ConfigsAll`](@ref) to enumerate all sets satisfying the independence constraint.
 all_independent_sets = solve(problem, ConfigsAll())[]

examples/Matching.jl

@@ -49,6 +49,7 @@ problem = GenericTensorNetwork(matching)
 # ## Solving properties
 # The maximum matching size can be obtained by
 max_matching = solve(problem, SizeMax())[]
+read_size(max_matching)
 # The largest number of matching is 5, which means we have a perfect matching (vertices are all paired).
 
 # The graph polynomial defined for the matching problem is known as the matching polynomial.
@@ -59,14 +60,16 @@ max_matching = solve(problem, SizeMax())[]
 # where ``k`` is the number of matches, and coefficients ``c_k`` are the corresponding counting.
 
 matching_poly = solve(problem, GraphPolynomial())[]
+read_size_count(matching_poly)
 
 # ### Configuration properties
 
 # ##### one of the perfect matches
 match_config = solve(problem, SingleConfigMax())[]
+read_size_config(match_config)
 
 # Let us show the result by coloring the matched edges to red
 show_graph(graph, locations; format=:svg, edge_colors=
-    [isone(match_config.c.data[i]) ? "red" : "black" for i=1:ne(graph)])
+    [isone(read_config(match_config)[i]) ? "red" : "black" for i=1:ne(graph)])
 
 # where we use edges with red color to related pairs of matched vertices.

examples/MaxCut.jl

@@ -70,7 +70,7 @@ max_config = solve(problem, GraphPolynomial())[]
 
 # ### Configuration properties
 # ##### finding one max cut solution
-max_vertex_config = solve(problem, SingleConfigMax())[].c.data
+max_vertex_config = read_config(solve(problem, SingleConfigMax())[])
 
 max_cut_size_verify = cut_size(graph, max_vertex_config)
 

examples/MaximalIS.jl

@@ -66,7 +66,7 @@ counting_min_maximal_independent_set = solve(problem, CountingMin())[]
 
 # ### Configuration properties
 # ##### finding all maximal independent set
-maximal_configs = solve(problem, ConfigsAll())[]
+maximal_configs = read_config(solve(problem, ConfigsAll())[])
 
 all(c->is_maximal_independent_set(graph, c), maximal_configs)
 
@@ -81,7 +81,7 @@ cliques = maximal_cliques(complement(graph))
 
 # ##### finding minimum maximal independent set
 # It is the [`ConfigsMin`](@ref) property in the program.
-minimum_maximal_configs = solve(problem, ConfigsMin())[].c
+minimum_maximal_configs = read_config(solve(problem, ConfigsMin())[])
 
 show_configs(graph, locations, reshape(collect(minimum_maximal_configs), 2, 5); padding_left=20)