fix typo

Author: GiggleLiu

docs/src/index.md

@@ -8,8 +8,8 @@ This package implements generic tensor networks to compute *solution space prope
 The *solution space properties* include
 * The maximum/minimum solution sizes,
 * The number of solutions at certain sizes,
-* The enumeration of solutions at certian sizes.
-* The direct sampling of solutions at certian sizes.
+* The enumeration of solutions at certain sizes.
+* The direct sampling of solutions at certain sizes.
 
 The solvable problems include [Independent set problem](@ref), [Maximal independent set problem](@ref), [Cutting problem (Spin-glass problem)](@ref), [Vertex matching problem](@ref), [Binary paint shop problem](@ref), [Coloring problem](@ref), [Dominating set problem](@ref), [Set packing problem](@ref) and [Set covering problem](@ref).
 

docs/src/performancetips.md

@@ -25,7 +25,7 @@ problem = Coloring{3}(graph);
 
 # ### Theory (can skip)
 # Type [`Coloring`](@ref) can be used for constructing the tensor network with optimized contraction order for a coloring problem.
-# Let us use 3-colouring problem defined on vertices as an example.
+# Let us use 3-coloring problem defined on vertices as an example.
 # For a vertex ``v``, we define the degree of freedoms ``c_v\in\{1,2,3\}`` and a vertex tensor labelled by it as
 # ```math
 # W(v) = \left(\begin{matrix}
@@ -42,7 +42,7 @@ problem = Coloring{3}(graph);
 #     x & x & 1
 # \end{matrix}\right).
 # ```
-# The number of possible colouring can be obtained by contracting this tensor network by setting vertex tensor elements ``r_v, g_v`` and ``b_v`` to 1.
+# The number of possible coloring can be obtained by contracting this tensor network by setting vertex tensor elements ``r_v, g_v`` and ``b_v`` to 1.
 
 # ## Solving properties
 # ##### counting all possible coloring

examples/Coloring.jl

@@ -28,7 +28,7 @@ problem = DominatingSet(graph; optimizer=TreeSA());
 # ### Theory (can skip)
 # Let ``G=(V,E)`` be the target graph that we want to solve.
 # The tensor network representation map a vertex ``v\in V`` to a boolean degree of freedom ``s_v\in\{0, 1\}``.
-# We defined the restriction on a vertex and its neighbouring vertices ``N(v)``:
+# We defined the restriction on a vertex and its neighboring vertices ``N(v)``:
 # ```math
 # T(x_v)_{s_1,s_2,\ldots,s_{|N(v)|},s_v} = \begin{cases}
 #     0 & s_1=s_2=\ldots=s_{|N(v)|}=s_v=0,\\
@@ -37,7 +37,7 @@ problem = DominatingSet(graph; optimizer=TreeSA());
 # \end{cases}
 # ```
 # where ``w_v`` is the weight of vertex ``v``.
-# This tensor means if both ``v`` and its neighbouring vertices are not in ``D``, i.e., ``s_1=s_2=\ldots=s_{|N(v)|}=s_v=0``,
+# This tensor means if both ``v`` and its neighboring vertices are not in ``D``, i.e., ``s_1=s_2=\ldots=s_{|N(v)|}=s_v=0``,
 # this configuration is forbidden because ``v`` is not adjacent to any member in the set.
 # otherwise, if ``v`` is in ``D``, it has a contribution ``x_v^{w_v}`` to the final result.
 # One can check the contraction time space complexity of a [`DominatingSet`](@ref) instance by typing:

examples/DominatingSet.jl

@@ -123,7 +123,7 @@ show_graph(graph; locs=locations, vertex_colors=
 
 # ##### Enumerate all solutions best several solutions
 # We can use bounded or unbounded [`ConfigsMax`](@ref) to find all solutions with largest-K set sizes.
-# In most cases, the bounded (default) version is prefered because it can reduce the memory usage significantly.
+# In most cases, the bounded (default) version is preferred because it can reduce the memory usage significantly.
 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.

examples/IndependentSet.jl

@@ -71,4 +71,4 @@ max_cut_size_verify = cut_size(graph, max_vertex_config)
 show_graph(graph; locs=locations, vertex_colors=[
         iszero(max_vertex_config[i]) ? "white" : "red" for i=1:nv(graph)])
 
-# where red vertices and white vertices are seperated by the cut.
+# where red vertices and white vertices are separated by the cut.

examples/MaxCut.jl

@@ -27,16 +27,16 @@ problem = MaximalIS(graph; optimizer=TreeSA());
 # ### Theory (can skip)
 # Let ``G=(V,E)`` be the target graph that we want to solve.
 # The tensor network representation map a vertex ``v\in V`` to a boolean degree of freedom ``s_v\in\{0, 1\}``.
-# We defined the restriction on its neighbourhood ``N(v)``:
+# We defined the restriction on its neighborhood ``N(v)``:
 # ```math
 # T(x_v)_{s_1,s_2,\ldots,s_{|N(v)|},s_v} = \begin{cases}
 #     s_vx_v^{w_v} & s_1=s_2=\ldots=s_{|N(v)|}=0,\\
 #     1-s_v& \text{otherwise}.
 # \end{cases}
 # ```
-# The first case corresponds to all the neighbourhood vertices of ``v`` are not in ``I_{m}``, then ``v`` must be in ``I_{m}`` and contribute a factor ``x_{v}^{w_v}``,
+# The first case corresponds to all the neighborhood vertices of ``v`` are not in ``I_{m}``, then ``v`` must be in ``I_{m}`` and contribute a factor ``x_{v}^{w_v}``,
 # where ``w_v`` is the weight of vertex ``v``.
-# Otherwise, if any of the neighbouring vertices of ``v`` is in ``I_{m}``, ``v`` must not be in ``I_{m}`` by the independence requirement.
+# Otherwise, if any of the neighboring vertices of ``v`` is in ``I_{m}``, ``v`` must not be in ``I_{m}`` by the independence requirement.
 
 # Its contraction time space complexity of a [`MaximalIS`](@ref) instance is no longer determined by the tree-width of the original graph ``G``.
 # It is often harder to contract this tensor network than to contract the one for regular independent set problem.

examples/MaximalIS.jl

@@ -34,14 +34,14 @@ show_graph(graph; locs=locations, texts=string.(sequence), edge_colors=
 # and the goal becomes a min-cut problem defined on black edges.
 
 # ## Generic tensor network representation
-# Let us contruct the problem instance as bellow.
+# Let us construct the problem instance as bellow.
 problem = PaintShop(sequence);
 
 # ### Theory (can skip)
 # Type [`PaintShop`](@ref) can be used for constructing the tensor network with optimized contraction order for solving a binary paint shop problem.
 # To obtain its tensor network representation, we associating car ``c_i`` (the ``i``-th character in our example) with a degree of freedom ``s_{c_i} \in \{0, 1\}``,
 # where we use ``0`` to denote the first appearance of a car is colored red and ``1`` to denote the first appearance of a car is colored blue.
-# For each black edges ``(i, i+1)``, we define an edge tensor labeld by ``(s_{c_i}, s_{c_{i+1}})`` as follows:
+# For each black edges ``(i, i+1)``, we define an edge tensor labeled by ``(s_{c_i}, s_{c_{i+1}})`` as follows:
 # If both cars on this edge are their first or second appearance
 # ```math
 # B^{\rm parallel} = \left(\begin{matrix}
@@ -75,7 +75,7 @@ max_config = solve(problem, GraphPolynomial())[]
 
 # ### Counting properties
 # ##### graph polynomial
-# The graph polynomial of the binary paint shop problem in our convension is defined as
+# The graph polynomial of the binary paint shop problem in our convention is defined as
 # ```math
 # P(G, x) = \sum_{k=0}^{\delta(G)} p_k x^k 
 # ```
@@ -96,5 +96,5 @@ show_graph(graph; locs=locations, texts=string.(sequence),
 
 # Since we have different choices of initial color, the number of best solution is 2.
 
-# The following function will check the solution and return you the number of color switchs
+# The following function will check the solution and return you the number of color switches
 num_paint_shop_color_switch(sequence, painting1)

examples/PaintShop.jl

@@ -5,7 +5,7 @@
 
 # ## Problem definition
 # In logic and computer science, the [boolean satisfiability problem](https://en.wikipedia.org/wiki/Boolean_satisfiability_problem) is the problem of determining if there exists an interpretation that satisfies a given boolean formula.
-# One can specify a satisfiable problem in the [conjuctive normal form](https://en.wikipedia.org/wiki/Conjunctive_normal_form).
+# One can specify a satisfiable problem in the [conjunctive normal form](https://en.wikipedia.org/wiki/Conjunctive_normal_form).
 # In boolean logic, a formula is in conjunctive normal form (CNF) if it is a conjunction (∧) of one or more clauses,
 # where a clause is a disjunction (∨) of literals.
 using GenericTensorNetworks
@@ -26,7 +26,7 @@ satisfiable(cnf, assignment)
 problem = Satisfiability(cnf);
 
 # ### Theory (can skip)
-# We can contruct a [`Satisfiability`](@ref) problem to solve the above problem.
+# We can construct a [`Satisfiability`](@ref) problem to solve the above problem.
 # To generate a tensor network, we map a boolean variable ``x`` and its negation ``\neg x`` to a degree of freedom (label) ``s_x \in \{0, 1\}``,
 # where 0 stands for variable ``x`` having value `false` while 1 stands for having value `true`.
 # Then we map a clause to a tensor. For example, a clause ``¬x ∨ y ∨ ¬z`` can be mapped to a tensor labeled by ``(s_x, s_y, s_z)``.

examples/Satisfiability.jl

@@ -1,4 +1,6 @@
-# # Open degree of freedoms
+# # 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.
 # Let us use the maximum independent set problem on Petersen graph as an example.
 #
 using GenericTensorNetworks, Graphs
@@ -10,10 +12,5 @@ problem = IndependentSet(graph; openvertices=[1,2,3])
 
 mis_tropical_tensor = solve(problem, SizeMax())
 
-# The MIS tropical tensor shows the MIS size under different configuration of open vertices.
-# It is useful in MIS tropical tensor analysis.
-# We can compatify (reference to be added) this MIS-Tropical tensor by typing
-
-mis_compactify!(mis_tropical_tensor)
-
-# It will eliminate some entries having no contribution to the MIS size when embeding this local graph into a larger one.
+# 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).