\n",
"\n",
"# The Square-Sum Chain Problem\n",
"\n",
"The Square-Sum Chain Problem is this:\n",
"\n",
"> Rearrange the integers 1 to *n* into a linear chain such that adjacent pairs of integers adds up to a perfect square.\n",
"\n",
"The problem is oft-discussed (e.g., [Numberphile](https://www.youtube.com/watch?v=G1m7goLCJDY), [reddit](https://www.reddit.com/r/dailyprogrammer/comments/7t6fnc/20180126_challenge_348_hard_find_chains/), [MAA](https://www.maa.org/sites/default/files/pdf/awards/college.math.j.46.4.264.pdf), OEIS [A090460](https://oeis.org/A090460), [A090461](https://oeis.org/A090461) [A071983](https://oeis.org/A071983), [A071984](https://oeis.org/A071984)). There are several variants:\n",
"\n",
"1. Given *n*, find a valid chain.\n",
"2. Given *n*, count the number of valid chains.\n",
"3. Do this efficiently, for all *n* from 1 up to a largish bound.\n",
"5. Require the integers to form a [circular chain](https://www.tutorialspoint.com/statistics/circular_permutation.htm), where the last integer is considered to be adjacent to the first.\n",
"6. Do the above with [cubes](https://math.stackexchange.com/questions/1168983/arranging-numbers-from-1-to-n-such-that-the-sum-of-every-two-adjacent-number) (or higher powers) instead of squares.\n",
"4. Prove what happens as *n* goes to infinity.\n",
"\n",
"# Vocabulary\n",
"\n",
"The key concepts for this problem:\n",
"- **Chain**: a permutation of the integers 1 to *n*, where each adjacent **pair** sums to a **perfect square**. Implemented as a list.\n",
"- **Pair**: two **adjacent** integers in a chain.\n",
"- **Circular chain**: a chain that loops back on itself so the first and last integers are **adjacent**.\n",
"- **Partial chain**: an incomplete chain that contains only some of the integers 1 to *n*.\n",
"- ***n***: the size of the chain. \n",
"- ***i, j***: integers in the chain.\n",
"- ***k***: an index into a chain.\n",
"- **Adjacency Graph**: a [graph](https://en.wikipedia.org/wiki/Graph_%28discrete_mathematics%29) where the vertices are the integers 1 to *n*, and a link between *i* and *j* means that *i* + *j* is a perfect square. The name reflects both the fact that linked integers in the graph can be adjacent in the chain, and that the graph can be represented with [adjacency lists](https://en.wikipedia.org/wiki/Adjacency_list). Here is the graph for *n* = 15:\n",
"[![](SquareSum15.jpg)](http://jackxmorris.com/posts/square-sum)\n",
"- **Hamiltonian Path**: a path that visits every vertex in a graph exactly once, such as 8⇒1⇒15⇒10⇒6⇒3⇒13⇒...⇒9 in the graph above.\n",
"- **Graph Search**: We can use a [graph search algorithm](https://en.wikipedia.org/wiki/Graph_traversal#Graph_traversal_algorithms) such as [depth-first search](https://en.wikipedia.org/wiki/Depth-first_search) to search for Hamiltonian paths on a graph. Such an algorithm considers **partial chains**, extending them as possible, or discarding them and moving on to alternatives. For example:\n",
" - On the graph above, suppose we have gotten to the partial chain 8⇒1⇒3, which we can represent as the list `[8, 1, 3]`.\n",
" - We will find that there is no way to complete a Hamiltonian path from this partial chain. (If we link to 6 next we will return to 1 a second time; if we link to 13 we will never reach 6.)\n",
" - But we can give up on that chain and consider `[8, 1, 15]`; from there it is easy to find a valid chain.\n",
"\n",
"\n",
"# Imports, Types, and Utility Functions\n",
"\n",
"Let's get these out of the way first:"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"import random\n",
"import time\n",
"import matplotlib.pyplot as plt\n",
"from typing import *\n",
"from math import sqrt, sin, cos, pi as 𝜋\n",
"from collections import Counter, defaultdict"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
"Chain = list # A chain of integers, e.g. [8, 1, 15, ...]\n",
"Pair = Tuple[int, int] # A pair of adjacent integers\n",
"Graph = Dict[int, List[int]] # Adjacency graph, e.g. {1: [3, 8, 15], 2: [7, 14], ...}"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [],
"source": [
"def first(iterable): \"First element, or None.\"; return next(iter(iterable), None)\n",
"\n",
"def ints(n) -> range: \"Integers from 1 to n inclusive.\"; return range(1, n + 1)\n",
"\n",
"def is_square(n: int) -> bool: \"Is `n` a perfect square?\"; return sqrt(n).is_integer()\n",
"\n",
"def count(iterable) -> int: \n",
" \"Number of truthy elements in iterable.\"\n",
" return sum(1 for x in iterable if x)\n",
"\n",
"def pairs(chain, circular=False) -> List[Pair]:\n",
" \"\"\"All pairs (i, j) of adjacent integers in chain.\"\"\"\n",
" return [(chain[k - 1], chain[k]) # If `circular` is True, include (chain[-1], chain[0])\n",
" for k in range(1 - circular, len(chain))]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Adjacency Graphs\n",
"\n",
"Computing an adjacency graph is straightforward:"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [],
"source": [
"def adjacency_graph(n) -> Graph:\n",
" \"\"\"Build {i: [j, ...]} to indicate that j can be adjacent to i in a chain of length n.\"\"\"\n",
" return {i: [j for j in ints(n) if i != j and is_square(i + j)]\n",
" for i in ints(n)}"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Here is the adjacency graph for *n* = 15. You can verify that it matches the graph shown above."
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"{1: [3, 8, 15],\n",
" 2: [7, 14],\n",
" 3: [1, 6, 13],\n",
" 4: [5, 12],\n",
" 5: [4, 11],\n",
" 6: [3, 10],\n",
" 7: [2, 9],\n",
" 8: [1],\n",
" 9: [7],\n",
" 10: [6, 15],\n",
" 11: [5, 14],\n",
" 12: [4, 13],\n",
" 13: [3, 12],\n",
" 14: [2, 11],\n",
" 15: [1, 10]}"
]
},
"execution_count": 5,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"adjacency_graph(15)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Depth-First Graph Search \n",
"\n",
"I'll define `find_chains(n)` to do the depth-first search to find chains of length `n`. The algorithm is:\n",
"\n",
" - Precompute the adjacency graph.\n",
" - Assign `stack` to be a stack of partial chains; initially one-element chains, one for each vertex in the graph.\n",
" - On each pass through the `while` loop, pop a partial chain off the stack, and do the following with it:\n",
" - If it is a complete chain (of length `n`), yield it as a valid solution.\n",
" - Otherwise, add new chains to the stack, one for each integer `j` in the adjacency graph that can be added to the partial chain.\n",
"\n",
"For now, only linear chains are allowed. \n",
"Here's the code:"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [],
"source": [
"def find_chains(n) -> Iterator[Chain]:\n",
" \"\"\"Yield all chains of 1..n rearranged so every adjacent pair sums to a square.\"\"\"\n",
" graph = adjacency_graph(n)\n",
" stack = [[i] for i in graph]\n",
" while stack:\n",
" chain = stack.pop()\n",
" if len(chain) == n:\n",
" yield chain\n",
" else:\n",
" stack.extend([chain + [j] for j in graph[chain[-1]] if j not in chain])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"*Note*: why did I define `find_chains` to be a [generator function](https://docs.python.org/3/howto/functional.html#generators)? Because that way a single function can be used for two purposes: to efficiently find a single chain for a given *n*, and to exhaustively find all chains for a given *n*. \n",
"\n",
"# Solving Problems\n",
"\n",
"We can now solve some of the variant problems (at least for small *n* and for linear chains):"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [],
"source": [
"n = 15 # Given n,"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"True"
]
},
"execution_count": 8,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"any(find_chains(n)) # Are there any valid chains of length n?"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[9, 7, 2, 14, 11, 5, 4, 12, 13, 3, 6, 10, 15, 1, 8]"
]
},
"execution_count": 9,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"first(find_chains(n)) # Find a valid chain."
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"2"
]
},
"execution_count": 10,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"count(find_chains(n)) # Count the number of valid chains."
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[[9, 7, 2, 14, 11, 5, 4, 12, 13, 3, 6, 10, 15, 1, 8],\n",
" [8, 1, 15, 10, 6, 3, 13, 12, 4, 5, 11, 14, 2, 7, 9]]"
]
},
"execution_count": 11,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"list(find_chains(n)) # List the valid chains."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Note that these two chains are reversals of each other—you might want to count them as the same chain, but I will count them as two distinct ones.\n",
"\n",
"We can also answer questions \"for all *n* up to a bound,\" although we can't do a very large bound:"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"{15, 16, 17, 23, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39}"
]
},
"execution_count": 12,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"{n for n in range(2, 40) if any(find_chains(n))}"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Circular Chains\n",
"\n",
"I'll modify `find_chains` to yield circular chains when the optional argument `circular` is true.\n",
"\n",
"This raises the question of what it means for two chains to be the same or different. If **ABCD** is a circular chain, then **BCDA** is in some sense the same circular chain (i.e., **A**+**D** is a perfect square), just starting from a different place. I'll use the convention that, I'll only report one starting place for each circular chain, and I'll arbitrarily choose that starting place to be the integer 1. I will however still count reversals (e.g., both **ABCD** and **DCBA**)."
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [],
"source": [
"def find_chains(n, circular=False) -> Iterator[Chain]:\n",
" \"\"\"Yield all chains of 1..n rearranged so every adjacent pair sums to a square.\n",
" If `circular` is true, then chain[0] and chain[-1] are considered adjacent.\"\"\"\n",
" graph = adjacency_graph(n)\n",
" stack = [[i] for i in ({1} if circular else graph)]\n",
" while stack:\n",
" chain = stack.pop()\n",
" if len(chain) == n and (is_circular(chain) or not circular):\n",
" yield chain\n",
" elif len(chain) < n:\n",
" stack.extend([chain + [j] for j in graph[chain[-1]] if j not in chain])\n",
" \n",
"def is_circular(chain) -> bool: \"Is `chain` circular?\"; return is_square(chain[0] + chain[-1])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"What's the smallest *n* that has a valid circular chain?"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"32"
]
},
"execution_count": 14,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"first(n for n in ints(100) if any(find_chains(n, circular=True)))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Making the Algorithm Faster\n",
"\n",
"\n",
"As a benchmark, I'll run `find_chains` for *n* from 1 to 50, check if each *n* has any linear chains, and see how long it takes:"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"CPU times: user 1min 18s, sys: 41.7 ms, total: 1min 18s\n",
"Wall time: 1min 18s\n"
]
},
{
"data": {
"text/plain": [
"31"
]
},
"execution_count": 15,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"%time count(any(find_chains(n)) for n in ints(50))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"It took over a minute. Can we speed things up? It turns out this problem is [NP-hard](https://en.wikipedia.org/wiki/NP-hardness) (according to [Jack Morris](http://jackxmorris.com/posts/square-sum)), so there really is no hope of finding an efficient solution for large *n*. However, there could be optimizationsthat give us constant-factor speedups. \n",
"\n",
"If we want to find all chains, we need to be resigned to essentially trying all possibilities. But if we are only interested in finding the first chain, we can change the **order** that we consider integers in the chains, to try to make it more likely that the first valid chain shows up earlier in the search. \n",
"\n",
"What order would be better? One in which we handle the most-constrained hard-to-match integers first–the integers with few links in the adjacency graph. That way, the search will quickly make many moves with little need to back up. For example, on the adjacency graph for *n* = 15, the integer 9 has only one adjacent integer so it comes first, followed by 7, which must be followed by 2 (since 9 is used), which must be followed by 14 (since 7 us used), which must be followed by 11 (since 2 is used), and so on. \n",
"\n",
"I'll redefine `adjacency_graph` to implement reordering with the function `reorder`, which uses the `link_count` as the key, but note that I have to reverse the results, because the stack is last-in-first-out, so I need to append the lowest-link-count integer last, so that it will be popped off the stack first."
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"outputs": [],
"source": [
"def adjacency_graph(n) -> Graph:\n",
" \"\"\"{i: [j, ...]} with i's and j's sorted by most links first.\"\"\"\n",
" graph = {i: [j for j in ints(n) if i != j and sqrt(i + j).is_integer()]\n",
" for i in ints(n)}\n",
" def link_count(i): return len(graph[i])\n",
" def reorder(integers): return sorted(integers, key=link_count, reverse=True)\n",
" return {i: reorder(graph[i]) for i in reorder(graph)}"
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"{1: [3, 15, 8],\n",
" 3: [1, 6, 13],\n",
" 2: [7, 14],\n",
" 4: [5, 12],\n",
" 5: [4, 11],\n",
" 6: [3, 10],\n",
" 7: [2, 9],\n",
" 10: [6, 15],\n",
" 11: [5, 14],\n",
" 12: [4, 13],\n",
" 13: [3, 12],\n",
" 14: [2, 11],\n",
" 15: [1, 10],\n",
" 8: [1],\n",
" 9: [7]}"
]
},
"execution_count": 17,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"adjacency_graph(n) # Reordered with the leaf 9 last; each list is reordered as well."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Will this new version of `adjacency_graph` give us a good speedup? (Note we haven't changed `find_chains` at all.)"
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"CPU times: user 870 ms, sys: 2.21 ms, total: 872 ms\n",
"Wall time: 871 ms\n"
]
},
{
"data": {
"text/plain": [
"31"
]
},
"execution_count": 18,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"%time count(any(find_chains(n)) for n in ints(50))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"That was a nice improvement! Nearly 100× faster on this particular benchmark! \n",
"\n",
"I have another idea, which should give a small speedup. The idea is to manage a [bitstring](https://en.wikipedia.org/wiki/Bit_array) to represent the integers in the chain, so that the test `if j not in chain` becomes an O(1) lookup, not an O(*n*) linear search. Instead of a stack entry being a chain like `[9, 7, 2]`, it would become a tuple like `([9, 7, 2], 0b1010000100)`, where `0b1010000100` means that the 9th, 7th, and 2nd bits are on (counting from 0 on the right). \n",
"\n",
"I'll also change the `stack.extend` to a `stack.append` inside a `for` loop, because the statement won't fit on one line anymore. This does give us the opportunity to save a little bit of time and memory by returning a chain as soon as it has length `n`, rather than putting it on the stack and popping it off later. "
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {},
"outputs": [],
"source": [
"old_find_chains = find_chains"
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {},
"outputs": [],
"source": [
"def find_chains(n, circular=False) -> Iterator[Chain]:\n",
" \"\"\"Yield all chains of 1..n rearranged so every adjacent pair sums to a square.\n",
" If `circular` is true, then chain[0] and chain[-1] are considered adjacent.\"\"\"\n",
" graph = adjacency_graph(n)\n",
" stack = [([i], 1 << i) for i in ({1} if circular else graph)]\n",
" while stack:\n",
" chain, bits = stack.pop()\n",
" for j in graph[chain[-1]]:\n",
" if not bits & (1 << j):\n",
" newchain = chain + [j]\n",
" newbits = bits | (1 << j)\n",
" if len(newchain) == n and (is_circular(newchain) or not circular):\n",
" yield newchain\n",
" elif len(newchain) < n:\n",
" stack.append((newchain, newbits))"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"CPU times: user 539 ms, sys: 2.43 ms, total: 542 ms\n",
"Wall time: 540 ms\n"
]
},
{
"data": {
"text/plain": [
"30"
]
},
"execution_count": 21,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"%time count(any(find_chains(n)) for n in ints(50))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"That's about a 40% improvement; better than I hoped for! \n",
"\n",
"But note that the two versions of `find_chains` give **different answers** for *n* = 1. The original version said that `[1]` is a valid linear chain (which makes sense because it is a permutation of the integers from 1 to 1, and every pair sums to a perfect square, because there are no pairs). In contrast, the revised version says that `[1]` is not a valid chain (which also makes sense if you interpret the problem as saying that all integers in the chain have to be part of a pair that forms a perfect square). Which interpretation is correct? There's no definitive answer. (Likewise for the question of whether `[]` is a valid chain for *n* = 0.) "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Visualization\n",
"\n",
"I'd like to understand more about chains, with an emphasis on circular ones. Visualizations can help. The function `circle` takes as input either a chain or an adjacency graph of size *n*, and does the following:\n",
"- Plot the integers 1 to *n* as vertices in a circle, in clockwise order like a clock face.\n",
"- Plot lines between integers to indicate a link (the links in a chain, or all the links in an adjacency graph).\n",
" - All lines with the same *i* + *j* sum will be of the same color, and will be parallel to each other.\n",
"- Print the [*degree counts*](https://en.wikipedia.org/wiki/Degree_%28graph_theory%29): the number of vertices (integers) with each degree. (`{1: 2, 2: 11, 3: 1}` means there are 2 vertices (leaves) with 1 link; 11 vertices with two links; and 2 vertices with 3 links.)\n",
"- Print the number of links that sum up to each perfect square. (`{4: 1, 9: 4, 16: 7, 25: 3}` means that there is 1 link whose integers sum to 4; 4 that sum to 9; 7 that sum to 16; and 3 that sum to 25.)"
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {},
"outputs": [],
"source": [
"def circle(x: Union[Chain, Graph]):\n",
" \"\"\"Visualize a graph or chain as a circle.\"\"\"\n",
" chain, graph = (x, graph_of(x)) if isinstance(x, Chain) else ([], x)\n",
" n = max(graph)\n",
" fig, ax = plt.subplots(figsize=(8, 8))\n",
" plt.axis('off')\n",
" 𝛼 = 2 * 𝜋 / n\n",
" X = [sin(𝛼 * i) for i in ints(n)]\n",
" Y = [cos(𝛼 * i) for i in ints(n)]\n",
" for i in graph: \n",
" for j in graph[i]: # Draw edges\n",
" color = colors[int(sqrt(i + j)) % len(colors)]\n",
" plt.plot([X[i-1], X[j-1]], [Y[i-1], Y[j-1]], '-', color=color)\n",
" ax.scatter(X, Y, color='k') # Draw vertices\n",
" for i in ints(n): # Draw integers next to vertices\n",
" vertex = (X[i - 1] * 1.1 - 0.02, Y[i - 1] * 1.1 - 0.02)\n",
" ax.annotate(i, vertex, annotation_clip=False)\n",
" def ctr(seq): return dict(sorted(Counter(seq).items())) # sorted Counter\n",
" print('Degree counts:', ctr(map(len, graph.values())))\n",
" print('Square counts:', ctr(i + j for i in graph for j in graph[i] if i > j))\n",
" if chain: print('Chain:', '-'.join(map(str, chain)))\n",
" \n",
"colors = 'c m y r g b orange lime deeppink brown silver'.split()\n",
"\n",
"def graph_of(chain: Chain) -> Graph:\n",
" \"\"\"Convert a chain, [i, j, ...] to a graph, {i: [j, ...], ...}.\"\"\"\n",
" graph = defaultdict(list)\n",
" for i, j in pairs(chain, is_circular(chain)):\n",
" graph[i].append(j)\n",
" graph[j].append(i)\n",
" return graph"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Visualizing a linear chain for *n* = 15\n",
"\n",
"Below is the chain for *n* = 15, followed by the adjacency graph (which is the same except for one more link, the yellow link between 1 and 3)."
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Degree counts: {1: 2, 2: 13}\n",
"Square counts: {9: 4, 16: 7, 25: 3}\n",
"Chain: 9-7-2-14-11-5-4-12-13-3-6-10-15-1-8\n"
]
},
{
"data": {
"image/png": "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\n",
"text/plain": [
"