open pit mining (#44)

* new mining

* fix negative pow for truncated poly

* update

* polish open pit mining, add branching method

Author: GiggleLiu

.vscode/settings.json

@@ -1,3 +1,2 @@
 {
-    "julia.environmentPath": "/home/leo/.julia/dev/GenericTensorNetworks"
 }

Project.toml

@@ -18,6 +18,7 @@ OMEinsum = "ebe7aa44-baf0-506c-a96f-8464559b3922"
 OMEinsumContractionOrders = "6f22d1fd-8eed-4bb7-9776-e7d684900715"
 Polynomials = "f27b6e38-b328-58d1-80ce-0feddd5e7a45"
 Primes = "27ebfcd6-29c5-5fa9-bf4b-fb8fc14df3ae"
+Printf = "de0858da-6303-5e67-8744-51eddeeeb8d7"
 Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
 Requires = "ae029012-a4dd-5104-9daa-d747884805df"
 SIMDTypes = "94e857df-77ce-4151-89e5-788b33177be4"

docs/src/ref.md

@@ -13,6 +13,7 @@ PaintShop
 Satisfiability
 SetCovering
 SetPacking
+OpenPitMining
 ```
 
 #### Graph Problem Interfaces
@@ -54,6 +55,9 @@ satisfiable
 ∨
 ¬
 ∧
+
+is_valid_mining
+print_mining
 ```
 
 ## Properties

src/GenericTensorNetworks.jl

@@ -6,7 +6,7 @@ using TropicalNumbers
 using OMEinsum
 using OMEinsum: timespace_complexity, getixsv
 using Graphs, Random
-using DelimitedFiles, Serialization
+using DelimitedFiles, Serialization, Printf
 
 # OMEinsum
 export timespace_complexity, timespacereadwrite_complexity, @ein_str, getixsv, getiyv
@@ -41,6 +41,7 @@ export DominatingSet, is_dominating_set
 export Matching, is_matching
 export SetPacking, is_set_packing
 export SetCovering, is_set_covering
+export OpenPitMining, is_valid_mining, print_mining
 
 # Interfaces
 export solve, SizeMax, SizeMin, CountingAll, CountingMax, CountingMin, GraphPolynomial, SingleConfigMax, SingleConfigMin, ConfigsAll, ConfigsMax, ConfigsMin, Single

src/arithematics.jl

@@ -169,6 +169,19 @@ function Base.show(io::IO, ::MIME"text/plain", x::TruncatedPoly{K}) where K
     end
 end
 
+Base.literal_pow(::typeof(^), a::TruncatedPoly, ::Val{b}) where b = a ^ b
+function Base.:^(x::TruncatedPoly{K,T,TO}, b::Integer) where {K,T,TO}
+    if b >= 0
+        return Base.power_by_squaring(x, b)
+    else
+        if count(!iszero, x.coeffs) <= 1
+            return TruncatedPoly{K,T,TO}(ntuple(i->iszero(x.coeffs[i]) ? x.coeffs[i] : x.coeffs[i] ^ b, K), x.maxorder*b)
+        else
+            error("can not apply negative power over truncated polynomial: $x")
+        end
+    end
+end
+
 ############################ ExtendedTropical #####################
 """
     ExtendedTropical{K,TO} <: Number
@@ -342,12 +355,15 @@ function Base.:+(a::ExtendedTropical{K,TO}, b::ExtendedTropical{K,TO}) where {K,
     return ExtendedTropical{K,TO}(res)
 end
 
+Base.literal_pow(::typeof(^), a::ExtendedTropical, ::Val{b}) where b = a ^ b
 Base.:^(a::ExtendedTropical, b::Integer) = Base.invoke(^, Tuple{ExtendedTropical, Real}, a, b)
 function Base.:^(a::ExtendedTropical{K,TO}, b::Real) where {K,TO}
     if iszero(b)  # to avoid NaN
         return one(ExtendedTropical{K,TO})
     else
-        return ExtendedTropical{K,TO}(a.orders .^ b)
+        # sort for negative order
+        # the -Inf cannot become possitive after powering
+        return ExtendedTropical{K,TO}(sort!(map(x->iszero(x) ? x : x^b, a.orders)))
     end
 end
 
@@ -812,6 +828,7 @@ for TYPE in [:AbstractSetNumber, :TruncatedPoly, :ExtendedTropical]
 end
 
 # to handle power of polynomials
+Base.literal_pow(::typeof(^), x::SumProductTree, ::Val{y}) where y = Base.:^(x, y)
 function Base.:^(x::SumProductTree, y::Real)
     if y == 0
         return one(x)
@@ -821,6 +838,7 @@ function Base.:^(x::SumProductTree, y::Real)
         error("pow of non-leaf nodes is forbidden!")
     end
 end
+Base.literal_pow(::typeof(^), x::ConfigEnumerator, ::Val{y}) where y = Base.:^(x, y)
 function Base.:^(x::ConfigEnumerator, y::Real)
     if y <= 0
         return one(x)
@@ -830,6 +848,7 @@ function Base.:^(x::ConfigEnumerator, y::Real)
         error("pow of configuration enumerator of `size > 1` is forbidden!")
     end
 end
+Base.literal_pow(::typeof(^), x::ConfigSampler, ::Val{y}) where y = Base.:^(x, y)
 function Base.:^(x::ConfigSampler, y::Real)
     if y <= 0
         return one(x)

src/networks/Coloring.jl

@@ -1,10 +1,22 @@
 """
     Coloring{K,CT<:AbstractEinsum, WT<:Union{NoWeight, Vector}} <: GraphProblem
-    Coloring{K}(graph; weights=NoWeight(), openvertices=(), optimizer=GreedyMethod(), simplifier=nothing)
+    Coloring{K}(graph; weights=NoWeight(), openvertices=(),
+            optimizer=GreedyMethod(), simplifier=nothing,
+            fixedvertices=Dict()
+        )
 
 The [Vertex Coloring](https://psychic-meme-f4d866f8.pages.github.io/dev/tutorials/Coloring.html) problem.
-`weights` has one to one correspondence with `edges(graph)`.
-`optimizer` and `simplifier` are for tensor network optimization, check [`optimize_code`](@ref) for details.
+
+Positional arguments
+-------------------------------
+* `graph` is the problem graph.
+
+Keyword arguments
+-------------------------------
+* `weights` are associated with the edges of the `graph`.
+* `optimizer` and `simplifier` are for tensor network optimization, check [`optimize_code`](@ref) for details.
+* `fixedvertices` is a dict to specify the values of degree of freedoms on vertices, where a value can be in ``0,...,K-1`` (different colors).
+* `openvertices` is a tuple of labels to specify the output tensor. Theses degree of freedoms will not be contracted.
 """
 struct Coloring{K,CT<:AbstractEinsum,WT<:Union{NoWeight, Vector}} <: GraphProblem
     code::CT

src/networks/DominatingSet.jl

@@ -1,11 +1,22 @@
 """
     DominatingSet{CT<:AbstractEinsum,WT<:Union{NoWeight, Vector}} <: GraphProblem
     DominatingSet(graph; weights=NoWeight(), openvertices=(),
-                 optimizer=GreedyMethod(), simplifier=nothing)
+            optimizer=GreedyMethod(), simplifier=nothing,
+            fixedvertices=Dict()
+        )
 
 The [dominating set](https://psychic-meme-f4d866f8.pages.github.io/dev/tutorials/DominatingSet.html) problem.
-In the constructor, `weights` are associated with vertices.
-`optimizer` and `simplifier` are for tensor network optimization, check [`optimize_code`](@ref) for details.
+
+Positional arguments
+-------------------------------
+* `graph` is the problem graph.
+
+Keyword arguments
+-------------------------------
+* `weights` are associated with the vertices of the `graph`.
+* `optimizer` and `simplifier` are for tensor network optimization, check [`optimize_code`](@ref) for details.
+* `fixedvertices` is a dict to specify the values of degree of freedoms on vertices, where a value can be `0` (absent in the set) or `1` (present in the set).
+* `openvertices` is a tuple of labels to specify the output tensor. Theses degree of freedoms will not be contracted.
 """
 struct DominatingSet{CT<:AbstractEinsum,WT<:Union{NoWeight, Vector}} <: GraphProblem
     code::CT

src/networks/IndependentSet.jl

@@ -1,12 +1,34 @@
 """
     IndependentSet{CT<:AbstractEinsum,WT<:Union{NoWeight, Vector}} <: GraphProblem
     IndependentSet(graph; weights=NoWeight(), openvertices=(),
-                 optimizer=GreedyMethod(), simplifier=nothing)
+            optimizer=GreedyMethod(), simplifier=nothing,
+            fixedvertices=Dict()
+        )
 
 The [independent set problem](https://psychic-meme-f4d866f8.pages.github.io/dev/tutorials/IndependentSet.html) in graph theory.
-In the constructor, `weights` are the weights of vertices.
-`openvertices` specifies labels for the output tensor.
-`optimizer` and `simplifier` are for tensor network optimization, check [`optimize_code`](@ref) for details.
+
+Positional arguments
+-------------------------------
+* `graph` is the problem graph.
+
+Keyword arguments
+-------------------------------
+* `weights` are associated with the vertices of the `graph`.
+* `optimizer` and `simplifier` are for tensor network optimization, check [`optimize_code`](@ref) for details.
+* `fixedvertices` is a dict to specify the values of degree of freedoms on vertices, where a value can be `0` (absent in the set) or `1` (present in the set).
+* `openvertices` is a tuple of labels to specify the output tensor. Theses degree of freedoms will not be contracted.
+
+Examples
+-------------------------------
+```jldoctest; setup=:(using Random; Random.seed!(2))
+julia> using GenericTensorNetworks, Graphs
+
+julia> problem = IndependentSet(smallgraph(:petersen));
+
+julia> solve(problem, ConfigsMax())
+0-dimensional Array{CountingTropical{Float64, ConfigEnumerator{10, 1, 1}}, 0}:
+(4.0, {0101010001, 1010000011, 0100100110, 0010111000, 1001001100})ₜ
+```
 """
 struct IndependentSet{CT<:AbstractEinsum,WT<:Union{NoWeight, Vector}} <: GraphProblem
     code::CT

src/networks/Matching.jl

@@ -1,10 +1,22 @@
 """
     Matching{CT<:AbstractEinsum, WT<:Union{NoWeight,Vector}} <: GraphProblem
-    Matching(graph; weights=NoWeight(), openvertices=(), optimizer=GreedyMethod(), simplifier=nothing)
+    Matching(graph; weights=NoWeight(), openvertices=(),
+            optimizer=GreedyMethod(), simplifier=nothing,
+            fixedvertices=Dict()
+        )
 
 The [Vertex matching](https://psychic-meme-f4d866f8.pages.github.io/dev/tutorials/Matching.html) problem.
-`weights` has one to one correspondence with `edges(graph)`.
-`optimizer` and `simplifier` are for tensor network optimization, check [`optimize_code`](@ref) for details.
+
+Positional arguments
+-------------------------------
+* `graph` is the problem graph.
+
+Keyword arguments
+-------------------------------
+* `weights` are associated with the edges of the `graph`.
+* `optimizer` and `simplifier` are for tensor network optimization, check [`optimize_code`](@ref) for details.
+* `fixedvertices` is a dict to specify the values of degree of freedoms on edges, where a value can be `0` (not matched) or `1` (mathced).
+* `openvertices` is a tuple of labels to specify the output tensor. Theses degree of freedoms will not be contracted.
 """
 struct Matching{CT<:AbstractEinsum, WT<:Union{NoWeight,Vector}} <: GraphProblem
     code::CT

src/networks/MaxCut.jl

@@ -1,11 +1,22 @@
 """
     MaxCut{CT<:AbstractEinsum,WT<:Union{NoWieght, Vector}} <: GraphProblem
     MaxCut(graph; weights=NoWeight(), openvertices=(),
-                optimizer=GreedyMethod(), simplifier=nothing)
+            optimizer=GreedyMethod(), simplifier=nothing,
+            fixedvertices=Dict()
+        )
 
 The [cutting](https://psychic-meme-f4d866f8.pages.github.io/dev/tutorials/MaxCut.html) problem (or spin glass problem).
-In the constructor, `weights` are the weights of edges.
-`optimizer` and `simplifier` are for tensor network optimization, check [`optimize_code`](@ref) for details.
+
+Positional arguments
+-------------------------------
+* `graph` is the problem graph.
+
+Keyword arguments
+-------------------------------
+* `weights` are associated with the edges of the `graph`.
+* `optimizer` and `simplifier` are for tensor network optimization, check [`optimize_code`](@ref) for details.
+* `fixedvertices` is a dict to specify the values of degree of freedoms, where a value can be `0` (in one side of the cut) or `1` (in the other side of the cut).
+* `openvertices` is a tuple of labels to specify the output tensor. Theses degree of freedoms will not be contracted.
 """
 struct MaxCut{CT<:AbstractEinsum,WT<:Union{NoWeight, Vector}} <: GraphProblem
     code::CT