Error users earlier, add Single type (#43)

* output array consistently

* save

* Redesign ConfigsMax(K)

* error on k<=0

Author: GiggleLiu

.vscode/settings.json

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

examples/open.jl

@@ -1,16 +1,32 @@
-# # Open degrees of freedom
-# Open degrees of freedom is useful when the graph under consideration is an induced subgraph of another graph.
-# The vertices connected to the rest part of the parent graph can not be summed over directly, which can be specified with the `openvertices` keyword argument in the graph problem constructor.
+# # Open and fixed degrees of freedom
+# Open degrees of freedom is useful when one want to get the marginal about certain degrees of freedom.
+# When one specifies the `openvertices` keyword argument in [`solve`](@ref) function as a tuple of vertices, the output will be a tensor that can be indexed by these degrees of freedom.
 # Let us use the maximum independent set problem on Petersen graph as an example.
 #
 using GenericTensorNetworks, Graphs
 
 graph = Graphs.smallgraph(:petersen)
 
 # The following code computes the MIS tropical tensor (reference to be added) with open vertices 1, 2 and 3.
-problem = IndependentSet(graph; openvertices=[1,2,3])
+problem = IndependentSet(graph; openvertices=[1,2,3]);
 
-mis_tropical_tensor = solve(problem, SizeMax())
+marginal = solve(problem, SizeMax())
 
 # The return value is a rank-3 tensor, with its elements being the MIS sizes under different configuration of open vertices.
 # For the maximum independent set problem, this tensor is also called the MIS tropical tensor, which can be useful in the MIS tropical tensor analysis (reference to be added).
+
+# One can also specify the fixed degrees of freedom by providing the `fixedvertices` keyword argument as a `Dict`, which can be used to get conditioned probability.
+# For example, we can use the following code to do the same calculation as using `openvertices`.
+problem = IndependentSet(graph; fixedvertices=Dict(1=>0, 2=>0, 3=>0));
+
+output = zeros(TropicalF64,2,2,2);
+
+marginal_alternative = map(CartesianIndices((2,2,2))) do ci
+    problem.fixedvertices[1] = ci.I[1]-1
+    problem.fixedvertices[2] = ci.I[2]-1
+    problem.fixedvertices[3] = ci.I[3]-1
+    output[ci] = solve(problem, SizeMax())[]
+end
+
+# One can easily check this one also gets the correct marginal on vertices 1, 2 and 3.
+# As a reminder, their computational hardness can be different, because the contraction order optimization program can optimize over open degrees of freedom.

src/GenericTensorNetworks.jl

@@ -43,7 +43,7 @@ export SetPacking, is_set_packing
 export SetCovering, is_set_covering
 
 # Interfaces
-export solve, SizeMax, SizeMin, CountingAll, CountingMax, CountingMin, GraphPolynomial, SingleConfigMax, SingleConfigMin, ConfigsAll, ConfigsMax, ConfigsMin
+export solve, SizeMax, SizeMin, CountingAll, CountingMax, CountingMin, GraphPolynomial, SingleConfigMax, SingleConfigMin, ConfigsAll, ConfigsMax, ConfigsMin, Single
 
 # Utilities
 export save_configs, load_configs, hamming_distribution, save_sumproduct, load_sumproduct

src/configurations.jl

@@ -35,12 +35,12 @@ function best_solutions(gp::GraphProblem; all=false, usecuda=false, invert=false
         T = config_type(CountingTropical{T,T}, length(labels(gp)), nflavor(gp); all, tree_storage)
         xs = generate_tensors(_x(T; invert), gp)
         ret = bounding_contract(AllConfigs{1}(), gp.code, xst, ymask, xs)
-        return invert ? post_invert_exponent.(ret) : ret
+        return invert ? asarray(post_invert_exponent.(ret), ret) : ret
     else
         @assert ndims(ymask) == 0
         t, res = solution_ad(gp.code, xst, ymask)
         ret = fill(CountingTropical(asscalar(t).n, ConfigSampler(StaticBitVector(map(l->res[l], 1:length(res))))))
-        return invert ? post_invert_exponent.(ret) : ret
+        return invert ? asarray(post_invert_exponent.(ret), ret) : ret
     end
 end
 
@@ -63,7 +63,7 @@ function solutions(gp::GraphProblem, ::Type{BT}; all::Bool, usecuda::Bool=false,
     end
     T = config_type(BT, length(labels(gp)), nflavor(gp); all, tree_storage)
     ret = contractx(gp, _x(T; invert); usecuda=usecuda)
-    return invert ? post_invert_exponent.(ret) : ret
+    return invert ? asarray(post_invert_exponent.(ret), ret) : ret
 end
 
 """
@@ -79,7 +79,7 @@ function bestk_solutions(gp::GraphProblem, k::Int; invert::Bool=false, tree_stor
     T = config_type(TruncatedPoly{k,T,T}, length(labels(gp)), nflavor(gp); all=true, tree_storage)
     xs = generate_tensors(_x(T; invert), gp)
     ret = bounding_contract(AllConfigs{k}(), gp.code, xst, ymask, xs)
-    return invert ? post_invert_exponent.(ret) : ret
+    return invert ? asarray(post_invert_exponent.(ret), ret) : ret
 end
 
 """