Algorithm that runs very long for some parameters and never halts for others

Question

11 days ago I asked a similar question with a specific narrow focus, to which there is probably no answer. So here I am asking about the underlying problem.

I teach computer science and would like to discuss Turing's halting problem¹ with my students. As an introduction to this topic, I would like to give them two computer programs (written in Python) with these properties:

The two programs should be as similar as possible. Ideally, they should differ only by one numeric literal, and this difference should be very small.
The two programs should not read any input. All parameters are defined within the program.
The two programs should be very short and easy to understand. The shorter the better. No more than 10 lines of code (not counting comments and blank lines).

The students are asked to tell which of the two programs halts and which runs forever. They should suggest methods how to find out the right solution.

I think a good approach is to code a math problem that has a solution for some small input parameter with a large number as the result, while having no solution at all for another small input parameter.

My first attempt was a Python program that computes the greatest common divisor of some simple expressions in a loop, halting after about $8\cdot10^{51}$ cycles:

import math
n = 1
gcd = 1
while gcd == 1:
    n += 1
    gcd = math.gcd(n ** 17 + 9, (n + 1) ** 17 + 9)
print("n   =",n)
print("gcd =",gcd)

So this program tries to find in a brute force approach the smallest $n$ for which

$$ \mathrm{gcd}(n^a+b,(n+c)^a+b)\ne1 $$

with $(a,b,c)=(17,9,1)$. (Compare OEIS A255859)

The print commands are not really necessary, so the program has 6 relevant lines of code and would run on an average common desktop computer for about $10^{41}$ years (that's about $7\cdot10^{29}$ times the age of the universe) and then it would output two numbers with 52 decimal places each.

This program is short and easy to understand. More importantly, without knowing the solution in advance and without advanced mathematical knowledge, it is virtually impossible to tell whether or not this program will eventually come to an end.

In the question linked to in the introduction, I asked for another value triple for $(a,b,c)$ that would cause the program to run forever. This would give the perfect never-stopping sibling program for the program shown here. But it seems that all non-trivial triples ($a\ne1\land c\ne1$) would cause the program to come to an end sooner or later.

Therefore, I need another mathematical problem that can be wrapped into two similar Python programs, one of which stops after a very long runtime, while the other runs forever.

What mathematical problems could these be, and with what parameters?

Just for your information:
My students are not studying math or computer science. Some of them study data science, the others information security. So most of them are interested in math, but it is not their major.

¹ Turing's Halting Problem in a nutshell: Is it possible to write a computer program that is a universal halting tester (UHT)? This UHT should be able to read any computer program and the input given to that program, and then tell whether the program with that input will halt (stop) at some point or whether it will keep running forever. The answer is: It is possible to write halting testers for many special cases, but it can be proved that the existence of a universal halting tester is impossible.

Addendum (reaction to answers given so far):

Thank you very much for the answers given so far. Most of them are really great! Thank you! But it would be really nice to have a problem, that has another property that I didn't mention explicitly:

When you add a print command inside the loop of the program shown here in my question, that prints the value of gcd in each round, then you get a list with more than $8\cdot10^{51}$ identical lines, each line showing the number $1$. And then, in its last round it for the very first time prints another number (which in this case has 52 decimal digits) and then halts.

I know, I didn't mention this property explicitly, but is there another problem that fulfills all criteria form above plus the additional criterion that it repeats the very same number in many rounds before it does something else?

How about: A variation of the Collatz conjecture that "obviously" (always) halts vs a variation that "obviously" (always) doesn't ? — Adam Rubinson, Jan 12 '23 at 10:40
Slight remark : The age of the universe is infinity. Not quite sure what exactly the question is but the busy beaver function shows that halting machines can take incredibly long , even for a small number of states. We know $$bb(7)>10\uparrow \uparrow 5$$ a power tower of $5$ tens. The running time of the halting champion for seven states is therefore already indistinguishable from the eternity. — Peter, Jan 12 '23 at 10:40
@AdamRubinson: The point is exactly that it should NOT be obvious at first sight whether a program stops or not. But there would have to be some proof. — Hubert Schölnast, Jan 12 '23 at 11:19
Ok well then replace "obvious" with "non-obvious" in my original comment. There should be such problems... — Adam Rubinson, Jan 12 '23 at 11:20
@Peter The age of the universe is about $1.38\cdot 10^{10}$ years, which is clearly shorter than infinity. Also $10\uparrow\uparrow 5$ is significantly smaller than infinity. But I think that a duration comparable to the age of the universe is sufficient. I've thought of busy beavers before, but I don't know of any busy beavers that can be proven to run forever, and it's hard to tell if that's the case. — Hubert Schölnast, Jan 12 '23 at 11:20

templatetypedef · Answer 1 · 2023-01-13T00:05:14.750

22

The sum of cubes problem gives a very nice twist on what you’re asking. Consider this pseudocode:

for n from 0 to infinity:
  for x from -n to +n:
    for y from -n to +n:
      for z from -n to +n:
        if x**3 + y**3 + z**3 = ____:
          halt

If you fill in the blank with…

… 113 the program never terminates,
… 114 no one knows whether it terminates, and
… 115 the program terminates.

This doesn’t quite meet the “halts after a very long time” criterion, but still illustrates the complexity of the halting problem.

If you want something that takes a very long time to halt, try setting the blanks to 33 (will take an astonishing amount of time to terminate) and 32 (never halts).

(I’ve used this example in my intro CS theory course because it’s super easy to state and yet immediately hits on an open problem. Students find this fascinating!)

edited Jan 13 '23 at 00:05

answered Jan 12 '23 at 17:13

templatetypedef

10,888

This is a great example – QC_QAOA Jan 12 '23 at 17:23
How long is "an astonishing amount of time"? Or, could you give the approximate size of $n$ when it halts? – mr_e_man Jan 12 '23 at 21:00
If the largest number in the solution is $k$, then the code will take something on the order of $8k^3$ steps to terminate. For $n = 33$ the numbers needed are on the order of $10^{15}$ and you’ll need about $10^{45}$ steps to finish.
The smallest solution for 33 uses numbers on the order of $10^{15}$, so the code will need to take about $10^{45}$ steps to finish.
– templatetypedef Jan 12 '23 at 21:13
That would take something like $10^{29}$ years... – mr_e_man Jan 12 '23 at 21:28
1

It seems to me that the number of times your program evaluates the if statement, with $n$ taking values $0,...,k$, is $1^3+3^3+...+(2k+1)^3=(k+1)^2(2k^2+4k+1)\sim 2k^4.$ So, if the largest number in the solution is $k≈10^{15},$ wouldn't that suggest about $2⋅10^{60}$ steps to finish? – r.e.s. Jan 12 '23 at 23:44
@r.e.s. My apologies, yes, you're correct. I forgot about the cost of all the loops up to $k$ itself. Thanks for pointing that out! – templatetypedef Jan 13 '23 at 00:03

Noah Schweber · Answer 2 · 2023-01-12T17:36:30.333

17

Consider an algorithm which searches, in a brute-force way, for a triple of positive integers $a,b,c$ such that $${a\over b+c}+{b\over a+c}+{c\over a+b}=4.$$ It turns out that this will eventually halt but not for a while, since the first triple of numbers satisfying the above conditions is

$154476802108746166441951315019919837485664325669565431700026634898253202035277999$, $36875131794129999827197811565225474825492979968971970996283137471637224634055579$, and $4373612677928697257861252602371390152816537558161613618621437993378423467772036$

On the other hand, replacing $4$ with $5$ (or any other odd number) results in an algorithm which will never halt, and I believe that fact is not obvious. And re: the broader question of which right-hand-side numbers result in a halting algorithm, it is currently unknown whether $\{n\in\mathbb{N}: \exists a,b,c\in\mathbb{N}({a\over b+c}+{b\over a+c}+{c\over a+b}=n)\}$ is even computable!

edited Jan 12 '23 at 17:36

answered Jan 12 '23 at 17:24

Noah Schweber

260,658

Just FYI ... Bremner & Macleod found the maximum number of digits among the elements of the first triple $(a,b,c)$ for various values of $n$ (the equation's RHS). Some large cases: $(n,\text{#digits})=(4,81),(6,134),(12,2707),(38,1584369),(178,398605460),(896,2.187,trillion).$ – r.e.s. Jan 13 '23 at 19:50
Suppose this were programmed in the same style as in another answer: for m=1..infty; for a=1..m; for b=1..m; for c=1..m; if f(a,b,c)=n then halt. The number of times the if would be evaluated up to $m=k$ (say), is then $1^3+2^3+...+k^3=k^2(k+1)^2/4\sim k^4/4.$ Since the largest number in the solution for $n=4$ is about $1.5,10^{80},$ there would be more than $10^{320}$ (!) evaluations required to finish. Even at a rate of $10^{100}$ evaluations per second, that would take more than $10^{212}$ years (and $n=896$ would require more than $10^{10^{12}}$ times that amount!). – r.e.s. Jan 13 '23 at 19:51

score 3 · Answer 3 · answered Jan 15 '23 at 01:49

(Generalized) Pell's equation can be a good source of big numbers. For example, consider the equation $$x^2 - 2017y^2 = K$$ and look for a solution in positive integers.

$K=0$ has no solutions. "Unfortunately", the proof that there are no solutions is so simple that a smarter student might figure it out on their own (especially if they are familiar with the proof that $\sqrt{2}$ is irrational).
The smallest solution for $K=1$ has more than $50$ decimal digits:$x_1=22691017898615873418283839489716246568157231499338273$. Finding this solution (and knowing it's minimal) requires a fair bit of understanding how Pell's equations work.
$K=3$ can be solved by a simple brute-force search, since the smallest solution has $x_3=5865694$ (of course, there are faster methods for finding this solution too).
$K=5$ might be a better no-solution example. Unlike the $K=0$ case, this one should not be easy to see as being unsolvable.

Thus, the following program (with $\_\_\_\_$ replaced by $K$) can finish quickly, rather slowly, or not at all.

x, y = 1, 1
while True:
   d = (xx - 2017y*y) - ____
   if d > 0:
      y += 1
   elif d < 0:
      x += 1
   else:
      break
print(x, y)

While not outright obvious, the unsolvability of $x^2-2017y^2=5$ can be demonstrated rather easily by considering the whole equation modulo $5$. The only remainders of squares modulo $5$ are $0$, $1$ and $4$, and the only combination that fits the equation is for both $x$ and $y$ being divisible by $5$. But that is impossible, since that would make the left-hand side of the equation divisible by $25$ but the right-hand side is not.

Will Jagy · Answer 4 · 2023-01-12T20:03:32.677

1

compare finding integers $$ x^2 + 27 y^2 = 7 z^3 + 14 $$ $$ x^2 + 27 y^2 = 7 z^3 + 6 $$

where the first one...

The relevant material is in Ireland and Rosen. This was the first example that Kaplansky found when I gave him some working programs

edited Jan 12 '23 at 20:03

answered Jan 12 '23 at 19:48

Will Jagy

146,052

r.e.s. · Answer 5 · 2023-01-19T23:42:09.083

The following program finds solutions of $2^n\bmod n = 2$ (i.e. positive integers $n$ such that when $2^n$ is divided by $n$ the remainder is $2$) until they exceed a specified size $N$:

n = 0; N = 10**10**6
while True:
    n += 1
    found = 1 if (pow(2,n,n) == 2 and n > N) else 0
    print(found, end=' ')  
    if found: break

On an ideal computer with unlimited resources, this program has the following properties for any positive integer $N$ (no matter how large!) :

It prints more than $N$ $0$s followed by a $1$, halting on the first solution larger than $N$. That such a solution must exist can be proved using Fermat's "little" theorem.
If == 2 is changed to == 1, the resulting program prints $0$s forever without halting. Proof of this is not trivial (e.g. the proof given here, again using Fermat's theorem).
found, as a function of $n$, is the indicator function for the event $(2^n\bmod n = 2 \ \ \text{ and }\ \ n > N)$. If the = 1 in its definition is replaced by = n, then the list of $0$s would be followed by $n$, rather than by $1$.

Note: A typical PC executes the statement N=10**10**6 and begins printing an infeasible number of $0$s almost immediately. Setting N=10**10**10, however, may require several days before the printing starts.

Algorithm that runs very long for some parameters and never halts for others

What mathematical problems could these be, and with what parameters?

5 Answers5

Linked