Simulated annealing approach to verify vertex adjacencies in the traveling salesperson polytope

TL;DR

This paper presents a heuristic simulated annealing method to verify nonadjacency of vertices in the traveling salesperson polytope, addressing an NP-complete problem with practical testing on random tours.

Contribution

It introduces a novel simulated annealing heuristic for verifying vertex nonadjacency in TSP polytopes, leveraging cycle covers and matchings.

Findings

Algorithm always correctly identifies nonadjacent vertices.

Tested successfully on random and pyramidal Hamiltonian tours.

Provides a practical approach to a known NP-complete problem.

Abstract

We consider 1-skeletons of the symmetric and asymmetric traveling salesperson polytopes whose vertices are all possible Hamiltonian tours in the complete directed or undirected graph, and the edges are geometric edges or one-dimensional faces of the polytope. It is known that the question whether two vertices of the symmetric or asymmetric traveling salesperson polytopes are nonadjacent is NP-complete. A sufficient condition for nonadjacency can be formulated as a combinatorial problem: if from the edges of two Hamiltonian tours we can construct two complementary Hamiltonian tours, then the corresponding vertices of the traveling salesperson polytope are not adjacent. We consider a heuristic simulated annealing approach to solve this problem. It is based on finding a vertex-disjoint cycle cover and a perfect matching. The algorithm has a one-sided error: the answer "not adjacent" is always correct, and was tested on random and pyramidal Hamiltonian tours.

Tables

Table 1. Table 1: Results for undirected pyramidal tours with number of tests t ​ i ​ m ​ e ​ s = 50 𝑡 𝑖 𝑚 𝑒 𝑠 50 times=50

	Exchange of random edges				Reconstructing with perfect matching
	Tours	Tours			Tours	Tours
	are not	are	Average	Accuracy,	are not	are	Average	Accuracy,
	found,	found,	time,	%,	found,	found,	time,	%,
N	$TN{F}_{avg}$	$T{F}_{avg}$	$T_{avg}$	$Acc$	$TN{F}_{avg}$	$T{F}_{avg}$	$T_{avg}$	$Acc$
8	$-$	9,84	9,84	100	$-$	5,57	5,57	100
16	5066,57	382,79	851,17	90	$-$	22,08	22,08	100
24	6549,75	1403,32	5005,82	30	9096,65	33,34	214,61	98
32	7832,24	1330,37	7312,09	8	$-$	224,93	224,93	100
40	10035,64	2351,53	9728,28	4	18656,05	610,26	971,18	98
48	13455,39	$-$	13455,39	0	27695,76	978,18	3649,94	90
64	16243,99	108,64	15921,28	2	48377,16	988,05	12361,43	76
96					98409,5	12293,68	53629,27	52
128	_				158485,17	21982,49	120264,4	28
192					334841,38	26165,54	297800,28	12

Table 2. Table 2: Results for directed pyramidal tours (Hopcroft-Karp algorithm), with the number of tests t ​ i ​ m ​ e ​ s = 50 𝑡 𝑖 𝑚 𝑒 𝑠 50 times=50 and number of fixed edges f ​ i ​ x ​ E ​ d ​ g ​ e ​ s ​ N = [ N / 3 ] 𝑓 𝑖 𝑥 𝐸 𝑑 𝑔 𝑒 𝑠 𝑁 delimited-[] 𝑁 3 fixEdgesN=[N/3]

	Tours	Tours	Average
	are not found,	are found,	time,	Accuracy, %,
N	$TN{F}_{avg}$	$T{F}_{avg}$	$T_{avg}$	$Acc$
8	$-$	2,27	2,27	100
16	$-$	5,03	5,03	100
24	$-$	19,75	19,75	100
32	$-$	19,14	19,14	100
40	$-$	40,89	40,89	100
48	$-$	95,38	95,38	100
64	$-$	689,20	689,20	100
96	$-$	330,21	330,21	100
128	129532,21	4514,36	9515,07	96
192	242480,51	15783,70	70190,93	76

Table 3. Table 3: Results for random Hamiltonian tours with the number of tests t ​ i ​ m ​ e ​ s = 50 𝑡 𝑖 𝑚 𝑒 𝑠 50 times=50

	Undirected tours				Directed tours
	Tours	Tours		Percentage	Tours	Tours		Percentage
	are not	are	Average	of found	are not	are	Average	of found
	found,	found,	time,	tours,	found,	found,	time,	tours,
N	$TN{F}_{avg}$	$T{F}_{avg}$	$T_{avg}$	%	$TN{F}_{avg}$	$T{F}_{avg}$	$T_{avg}$	%
8	1604,66	15,02	491,91	30	3118,99	4,05	2682,90	14
16	$-$	13,76	13,756	100	6799,17	4,71	4624,95	32
24	$-$	28,52	28,52	100	10594,29	9,38	8265,61	22
32	$-$	46,64	46,64	100	14764,29	39,19	10052,26	32
40	$-$	75,27	75,27	100	19184,31	19,33	15734,62	18
48	$-$	87,86	87,86	100	25214,48	142,08	19197,11	24
64	$-$	235,37	235,37	100	38886,56	238,95	29611,13	24
96	$-$	481,37	481,37	100	74654,25	1150,20	61423,52	18
128	$-$	827,42	827,42	100	121790,32	1851,29	95403,73	22
192	$-$	4064,84	4064,84	100	252321,67	8979,84	213386,98	16

Equations

$$x_e^v=\{\begin{array}{ll}1,& \text{ if the cycle }x\text{ contains an edge }e\in E,\\ 0,& \text{ otherwise. }\end{array}$$

$$y_a^v=\{\begin{array}{ll}1,& \text{ if the tour }y\text{ contains an edge }a\in A,\\ 0,& \text{ otherwise. }\end{array}$$

$$\mathrm{TSP}(n)=\mathrm{conv}\{x^v|x\in H{C}_n\}$$

$$\mathrm{ATSP}(n)=\mathrm{conv}\{y^v|y\in H{T}_n\}$$

$$z\cup w=x\cup y\text{ and }z\cap w=\varnothing ?$$

$$P=e^{-\frac{currE-candE}{T}},$$

$$\tau =(1,i_1,i_2,\dots ,i_r,n,j_1,j_2,\dots ,j_{n-r-2})$$

$$i_1<i_2<\dots <i_r\text{ and }{j}_1>j_2>\dots >j_{n-r-2}.$$

Full text

1 Introduction

We consider a classical traveling salesperson problem on a complete directed or undirected graph.

Symmetric traveling salesperson problem. Given a complete weighted graph $K_{n}=(V,E)$, it is required to find a Hamiltonian cycle of minimum weight.

Asymmetric traveling salesperson problem. Given a complete weighted digraph $D_{n}=(V,A)$, it is required to find a Hamiltonian tour of minimum weight.

We denote by $HC_{n}$ the set of all Hamiltonian cycles in $K_{n}$ and by $HT_{n}$ the set of all Hamiltonian tours in $D_{n}$. With each Hamiltonian cycle $x\in HC_{n}$ we associate a characteristic vector $x^{v}\in\mathbb{R}^{E}$ by the following rule:

[TABLE]

With each Hamiltonian tour $y\in HT_{n}$ we associate a characteristic vector $y^{v}\in\mathbb{R}^{A}$ by the following rule:

[TABLE]

The polytope

[TABLE]

is called the symmetric traveling salesperson polytope, and the polytope

[TABLE]

is called the asymmetric traveling salesperson polytope.

The $1$-skeleton of a polytope $P$ is the graph whose vertex set is the vertex set of $P$ (characteristic vectors $x^{v}$ for the traveling salesperson problem) and edge set is the set of geometric edges or one-dimensional faces of $P$. Many papers are devoted to the study of $1$-skeletons associated with combinatorial problems. On the one hand, the vertex adjacency in $1$-skeleton is of great interest for the development of algorithms to solve problems based on local search technique (when we choose the next solution as the best one among adjacent solutions). For example, various algorithms for perfect matching, set covering, independent set, ranking of objects, problems with fuzzy measures, and many others are based on this idea [2, 3, 10, 11, 15, 21]. On the other hand, some characteristics of $1$-skeletons, such as the diameter and the clique number, estimate the time complexity for different computation models and classes of algorithms [5, 6, 8, 17].

Unfortunately, the classical result by Papadimitriou states that the construction of 1-skeleton of the traveling salesperson polytope is NP-complete for both directed and undirected graphs.

Theorem 1.1 (Papadimitriou, [24])

The question whether two vertices of the polytopes $\operatorname{TSP}(n)$ or $\operatorname{ATSP}(n)$ are nonadjacent is NP-complete.

However, the vertex adjacency test for $\operatorname{TSP}(n)$ and $\operatorname{ATSP}(n)$ is an interesting problem itself. Note that a geometric approach to the construction of 1-skeleton of the traveling salesperson polytope seems not very promising because both polytopes have superexponential number of vertices and faces [14, 17].

In [25] the sufficient condition for vertex adjacency in the traveling salesperson polytope was reformulated in a combinatorial form.

Lemma 1 (Sufficient condition for nonadjacency)

If from the edges of two Hamiltonian tours $x$ and $y$ it is possible to construct two complementary Hamiltonian tours $z$ and $w$, then the corresponding vertices $x^{v}$ and $y^{v}$ of the polytope $\operatorname{TSP}(n)$ (or $\operatorname{ATSP}(n)$) are not adjacent.

From the geometric point of view, the Lemma 1 means that the segment connecting two vertices $x^{v}$ and $y^{v}$ intersects with the segment connecting two other vertices $z^{v}$ and $w^{v}$ of the polytope $\operatorname{TSP}(n)$ (or $\operatorname{ATSP}(n)$ correspondingly), thus it cannot be an edge in 1-skeleton. An example of a satisfied sufficient condition is shown in Fig. 1.

Let us formulate the sufficient condition for vertex nonadjacency of the traveling salesperson polytope in the form of a combinatorial problem.

Instance. Let $x$ and $y$ be two Hamiltonian tours.

Question. Does the multigraph $x\cup y$ include a pair of Hamiltonian tours $z$ and $w$ different from $x$ and $y$ such that

[TABLE]

By $x\cup y$ we denote a multigraph that contains all edges of both tours $x$ and $y$ (Fig. 2).

In this formulation, the problem is close to the $2$-peripatetic salesperson problem in which it is required to find two Hamiltonian tours of minimum weight without common edges. The $2$-peripatetic salesperson is NP-complete even for $4$-regular graphs [12]. Much attention was paid to the development of approximation algorithms for this problem (see, for example, [1, 4, 16]).

However, the combinatorial form of the sufficient condition for nonadjacency has a number of differences from the $2$-peripatetic salesperson problem:

• •

this is a decision problem, not an optimization one;

• •

the graph is a $4$-regular graph (or digraph) of a special form constructed as a union of two Hamiltonian tours;

• •

it is required to find two Hamiltonian tours different from $x$ and $y$.

Note also that if from the edges of two Hamiltonian tours $x$ and $y$ it is possible to construct another Hamiltonian tour $z$, then all the remaining edges $(x\cup y)\backslash z$ are almost certainly do not form a Hamiltonian tour (Fig. 2). Thus, instead of algorithms for a single Hamiltonian tour in the multigraph $x\cup y$, in this paper we consider a heuristic simulated annealing approach to test vertex adjacencies in the symmetric and asymmetric traveling salesperson polytopes based on finding a vertex-disjoint cycle cover and a perfect matching.

2 Simulated annealing

The simulated annealing borrows the concept from annealing in metallurgy where a metal material is repeatedly heated, kneaded, and cooled to enlarge the size of its crystals to eliminate defects [19].

We consider a general scheme of the Algorithm 1. It is required to minimize the energy function specified for the current system state. The algorithm starts from a certain initial state: at each step a neighbor candidate state is generated which energy is compared to the energy of the previous state. If the energy decreases, the system transits to the new state, otherwise it may transit with a certain probability (to prevent falling into the local minimum).

The algorithm receives input data in one of the following formats:

Two Hamiltonian tours $x=[a_{1},\ldots,a_{N}]$ and $y=[b_{1},\ldots,b_{N}]$, given as the permutations of vertices in a complete graph (or digraph) $K_{N}$; 2. 2.

$2/4$-regular graph ($2$ — for directed and $4$ — for undirected graphs) of size $N$, i.e. the union of two Hamiltonian tours, given as the adjacency list.

Other input parameters: the initial value of temperature $initT$, the maximum number of iterations $iterN$, and the the size of a queue of fixed edges $fixEdgesN$. The algorithm stops when the solution is found or when the number of iterations exceeds the value of the parameter $iterN$. As an output, the algorithms returns two complementary Hamiltonian tours $z$ and $w$ constructed from the edges of $x$ and $y$. By the sufficient condition (Lemma 1), the corresponding vertices $x^{v}$ and $y^{v}$ of the traveling salesperson polytope are not adjacent. If the algorithm cannot find the complementary tours, then it returns that the corresponding vertices are probably adjacent. Thus, the algorithm has a one-sided error: the answer “not adjacent” is always correct, while the answer “probably adjacent” leaves the possibility that the vertices actually are not adjacent.

3 Generation of the initial state

To generate the initial system state and neighbor candidate states, we construct a vertex-disjoint cycle cover of the multigraph $x\cup y$ (Fig. 3).

If $x$ and $y$ are undirected Hamiltonian cycles, then all vertices in the multigraph $x\cup y$ have degrees equal to $4$. Let $z$ be a vertex-disjoint cycle cover of $x\cup y$, then all the remaining edges form a graph $w=(x\cup y)\backslash z$ with all vertex degrees being equal to $2$. Thus, $w$ is also a vertex-disjoint cycle cover of $x\cup y$.

If $x$ and $y$ are directed Hamiltonian tours, then all vertices in the multigraph $x\cup y$ have both indegrees and outdegrees equal to $2$. Let $z$ be a vertex-disjoint cycle cover of $x\cup y$, then in the digraph $w=(x\cup y)\backslash z$ all vertices have both indegrees and outdegrees equal to $1$. Thus, $w$ is also a vertex-disjoint cycle cover of $x\cup y$.

Finding a vertex-disjoint cycle cover of both directed and undirected graph can be performed in polynomial time by a reduction to perfect matching [27]. Let us recall that a perfect matching is a set of pairwise nonadjacent edges which matches all vertices of the graph. The procedures for directed and undirected graphs are somewhat different. We consider them separately.

Let $x$ and $y$ be undirected Hamiltonian cycles.

1. Step 1.

From the multigraph $x\cup y=G=(V,E)$, we construct a new graph $G^{\prime}=(V^{\prime},E^{\prime})$. With each vertex $v\in V$ we associate a gadget $G_{v}$ that is a complete bipartite subgraph $K_{4,2}$ (note that the degree of $v$ equals 4) as it is shown in Fig. 4:

• •

there are $4$ vertices in the outer part ($v_{a}$, $v_{b}$, $v_{c}$ and $v_{d}$) that correspond to $4$ edges incident to $v$ in $G$ (edges $A$, $B$, $C$, $D$); these vertices are connected with other gadgets;

• •

there are $2$ vertices in the inner part ($v_{1}$ and $v_{2}$) that are connected only with the vertices of the outer part. 2. Step 2.

A perfect matching in $G^{\prime}$ corresponds to a vertex-disjoint cycle cover in the original graph $G$. Indeed, a perfect matching has to cover both inner vertices $v_{1}$ and $v_{2}$. Therefore, it includes exactly one edge of {$(v_{1},v_{a})$, $(v_{1},v_{b})$, $(v_{1},v_{c})$, $(v_{1},v_{d})$} and exactly one edge of $\{(v_{2},v_{a}),(v_{2},v_{b}),(v_{2},v_{c}),(v_{2},v_{d})\}$. Both of these edges cover exactly two vertices of $\{v_{a},v_{b},v_{c},v_{d}\}$. The other two vertices has to be covered by the edges that correspond to the edges of $G$ (Fig. 5). We include these edges into $z$, then the degree of each vertex $v$ in the graph $z$ equals $2$, and thus, $z$ is a vertex-disjoint cycle cover of the multigraph $x\cup y$.

A perfect matching in a general undirected graph can be found by Edmond’s algorithm [13] in $O(V^{2}E)$ time or using Micali-Vazirani matching algorithm [22] in $O(\sqrt{V}E)$ time. We have chosen Edmond’s algorithm as a more simple one to implement. Note that replacing it with a more efficient Micali-Vazirani algorithm does not require changing the rest of the algorithm.

Let $x$ and $y$ be directed Hamiltonian tours.

1. Step 1.

From the directed multigraph $x\cup y=D=(V,A)$, we construct a bipartite graph $D^{\prime}=(L,R,E)$. With each vertex $v\in V$ we associate a pair of vertices $v_{L}\in L$ and $v_{R}\in R$, and with each edge $(u,v)\in A$ we associate a new edge $(u_{L},v_{R})$ in the bipartite graph $D^{\prime}$ (Fig. 6). 2. Step 2.

A perfect matching in the bipartite graph $D^{\prime}$ corresponds to a vertex-disjoint directed cycle cover in the original graph $D$. Indeed, every vertex of $D$ is a head of exactly one edge and a tail of exactly one edge of a perfect matching in $D^{\prime}$ (Fig. 7).

A perfect matching in a bipartite graph can be found by Hopcroft–Karp algorithm [18] in $O(\sqrt{V}E)$ time.

4 Generation of a neighbor candidate state

A process of constructing a neighbor candidate state is shown in Procedure 2.

The algorithm receives as input the current state as the vertex-disjoint cycle covers $z$ and $w$, and the parameter $fixEdgesN$ that set the size of a queue of edges that are fixed in the graph $z$ and the corresponding perfect matching. When this limit is exceeded, the first edge of the queue is deleted.

In order to find a neighbor candidate state we chose an edge of $w$ with endpoints in two different connected components of $z$ and add it to the queue of fixed edges (Fig. 8, fixed edges of $z$ are dashed, an edge of $w$ that is added to the queue is dashed dotted). Such edge always exists due to the connectivity of the multigraph $x\cup y$ . If $z$ contains exactly one connected component, then the graphs $z$ and $w$ can be swapped. The idea of this procedure is to reduce the number of connected components in $z$ and $w$. The neighbor candidate state is constructed by the perfect matching algorithms with fixed edges forming the initial matching.

5 Cooling schedule

If a neighbor candidate state has two complementary Hamiltonian tours different from $x$ and $y$ (or any two complementary Hamiltonian tours, if the input is a $2/4$-regular graph), then the algorithm successfully stops and returns a solution.

Otherwise, the energy function is calculated for a neighbor candidate state. We have chosen the following function (Procedure 3): (number of connected components in $z$) + (number of connected components in $w$).

At each step of the algorithm the candidate states correspond to two vertex-disjoint cycle covers $z$ and $w$. Therefore, if the total number of connected components in $z$ and $w$ is equal to $2$, then $z$ and $w$ are Hamiltonian tours.

If the energy function has decreased compared to the previous state, then we accept a transition to the neighbor candidate state.

If the energy function has not decreased, then we make a transition with probability

[TABLE]

where $T$ is the current temperature, $currE$ is the current energy value, and $candE$ is the energy of the considered neighbor candidate state. Such transition is necessary to avoid the problem of falling into the local minimum.

The current temperature gradually decreases from $initT$ to [math], and its function depends on the initial temperature $initT$ and the index of the current iteration $k$ (Procedure 4).

6 Experiments

The algorithm to test vertex adjacencies in the polytopes $\operatorname{TSP}(n)$ and $\operatorname{ATSP}(n)$ was implemented as a console application with different input parameters. Some of them are described below:

--N

— number of vertices in the input graph/tour;

--times

— number of times to run the algorithm;

--iterN

— number of iterations in the simulated annealing algorithm;

--stateCandidate=random—match

— how to generate a neighbor candidate state:

1. random

: random exchange of edges between tours 2. match

: constructing a vertex-disjoint cycle cover and a perfect matching;

--exEdgesN

— number of edges to randomly exchange between tours (used only for --stateCandidate=random);

--ansN

— multistart: number of repeatedly runs of the algorithm (used only for --stateCandidate=random);

--fixEdgesN

— the size of a queue of edges that can be fixed in the initial matching (used only for --stateCandidate=match).

We tested the algorithm on random directed and undirected Hamiltonian tours, and also on directed and undirected pyramidal tours.

A Hamiltonian tour

[TABLE]

is called pyramidal if

[TABLE]

We chose pyramidal tours for experiments since for them the vertex adjacencies in the corresponding polytopes can be easily verified. In particular, the following problem: given two pyramidal tours $x$ and $y$, is it possible to construct two complementary tours $z$ and $w$ from the edges of $x$ and $y$, can be solved in linear time [8, 9]. Thus, we run the algorithm on pyramidal tours, for which it is known that the sufficient condition of Lemma 1 is satisfied. This allows us to estimate the error percentage when the algorithm could not find complementary tours that are guaranteed to exist.

The results of the tests for undirected pyramidal tours are presented in Table 1 (Edmond’s algorithm is used). The algorithm was run with the number of iterations $iterN=8000$ and the number of fixed edges $fixEdgesN=\lfloor N/3\rfloor$. In the previous version of the program [20] a different method to generate neighbor candidate state was implemented — the exchange of random edges between two subgraphs $z$ and $w$. Its results are also shown in the table for comparison. For the exchange of random edges the following input parameters were used: the number of iterations $iterN=50000$, the number of multistart attempts $ansN=5$ and the number of edges to exchange $exEdgesN=3$.

Note that compared to the exchange of random edges, both the accuracy of the algorithm and the size of solved problems have increased. The accuracy can also be adjusted by increasing the number of iterations or changing the maximum number of fixed edges in the queue.

The results of the tests for directed pyramidal tours and the Hopcroft-Karp algorithm are presented in Table 2. The input parameters are similar to the case with undirected tours. Here, for almost all considered sizes of test graphs, the algorithm works with the accuracy of $100\%$, which is a very good result.

Finally, Table 3 shows the test results for random directed and undirected Hamiltonian tours. From the table it can be concluded that for random tours the algorithm works even faster than for pyramidal tours. Note that for undirected graphs the algorithm finds complementary tours more often than for directed graphs. This is due to the fact that $1$-skeleton of the asymmetric traveling salesperson polytope is generally much more dense than $1$-skeleton of the symmetric polytope. For example, the diameter of $1$-skeleton of $\operatorname{ATSP}(n)$ is $2$ [23], while the best known upper bound for the diameter of $1$-skeleton of $\operatorname{TSP}(n)$ is $4$ [26]. Besides, for undirected cycles, the algorithm was able to find a solution for almost all cases. We can conclude that for the symmetric traveling salesperson polytope $\operatorname{TSP}(n)$ two random vertices are not adjacent with a very high probability.

The largest instance that was solved by the algorithm had random Hamiltonian tours on $4096$ vertices and required $1\,530\,682$ ms. However, due to the long waiting time for several tests, we limited the presented experiments to tours of size under $200$ vertices.

7 Conclusion

The construction and study of $1$-skeletons of the polytopes associated with intractable problems is of interest for the development and analysis of combinatorial algorithms. However, for such problems as the traveling salesperson even determining whether two vertices are adjacent or not is an NP-complete problem. This paper proposes an original heuristic approach based on simulated annealing to verify vertex adjacencies in $1$-skeleton of the traveling salesperson polytope. The algorithm has a one-sided error: the answer “not adjacent” is always correct, while the answer “probably adjacent” leaves the possibility that the vertices actually are not adjacent. The algorithm showed good practical results during the experiments.

Acknowledgments.

The research is supported by the grant of the President of the Russian Federation MK-2620.2018.1.