Talk:Halting problem/Archive 1

message: An anonymous user made an edit to the section of the importance of the halting problem, getting the proof by reduction part round exactly the wrong way (a common mistake).  Could people check that I have got it correct?  And is it too detailed for that part of the article? --Robert Merkel 10:28, 2 Nov 2004 (UTC)
replies: text: Looks good. I'd suggest a concrete example, though, even a made-up one would help. Deco 23:47, 2 Nov 2004 (UTC)
thread_title:  Reduction... 

message: The idea is: suppose there's a magical machine that can solve the halting problem. The super halting problem is to deside whether this machine halts. It seems that this problem cannot be solved by the "standard" turing machine or the magical one described earlier. A machine that could solve this problem could not solve it's own halting problem. Again, a machine that could solve it couldn't solve it's own halting problem. This leads to an infinite series of more and more powerful machines and "harder" halting problems. See http://www.scottaaronson.com/writings/bignumbers.html for much better explanation. (search for the phrase "super halting problem")
Should the page mention this or have link to page dedicated for this?
:Well, deciding if that particular machine will halt is easy. The answer is yes: because there is no Turing machine that neither halts nor doesn't halt, in order to be correct the halt-deciding machine must always halt. A more interesting question (the one your probably intended) is to ask how much "harder" the halting problem is on a Turing machine with an oracle for the halting problem. This is discussed at Oracle machine#Oracles and Halting Problems article, to which we could reasonably link. Deco 00:14, 14 May 2005 (UTC)
thread_title:  Super halting problems 

message: function findTwinPrimeAbove(int N)
     int p := N
     loop
         if p is prime and p + 2 is prime
             return
         else
             p := p + 1
I think this example is wrong. If there would be a proof we know the answer. I think this should be a function
for which we know there is not a proof because if "all proofs" are know then are there any functions left?
:This is just offered as evidence why it makes sense for the halting problem to be impossible to solve, because it would show that there is an automatic procedure for solving hard open problems in mathematics. There are very few problems that have proofs that they cannot be proven or disproven, and it's not clear to me how a program could test any of these. Deco 22:24, 15 Jun 2005 (UTC)
thread_title:  wrong examples? 

message: In this section it says:
:Can we recognize a correct PHS when we see it?
I think this is intended to mean: "can we construct a Turing machine that will infallibly determine whether a program given as input is itself a correct PHS", but that meaning isn't clear from the above expression, and it took me some time analysing the following text to decide that this is what was meant.
However, if I am correct about the meaning of the question, the answer also seems trivially "no" - take any incorrect PHS and prepend code to find the first odd perfect number, for example - and it seems odd then that the section spends so long focussing on this apparently trivial question. To me, the more obviously interesting question to consider is, given that it is clearly possible to construct some Turing machines that are provably correct PHSs, how good can we make them? Hv 13:49, 12 August 2005 (UTC)
replies: text: I agree with this. I'd like to see the discussion of the undecidability of this problem removed if there's consent. We can instead include a discussion of some well-known algorithms for partial deciding, such as those based on basic blocks and dead-code elimination that are used by compilers. Deco 22:32, 12 August 2005 (UTC)
replies: text: Note that Busy beaver chasers need to solve exactly this problem, so their documents would be a useful starting point for research. Hv 04:00, 13 August 2005 (UTC)
thread_title:  Recognizing partial solutions 

message: I ran across an interesting fact at Divisor function. It appears that the famous Riemann hypothesis, one of the million-dollar problems, is false if and only if the following very simple Turing machine terminates:
 function Riemann() {
     int n := 5041
     while true
         if sumOfDivisors(n)/(n*ln(ln(n)) ≥ e^y then
             return
         n := n + 1
 }
Here, sumOfDivisors computes the sum of the divisors of n, e is the number e, y is the Euler-Mascheroni constant, and computations are done with sufficient accuracy to conclusively determine whether the inequality holds (it suffices to use range arithmetic and increase accuracy until the range does not contain the constant). We have enough examples already, and this one is a bit more complicated, but it's amazing how many important open problems can be expressed in this way. Deco 04:39, 22 August 2005 (UTC)
thread_title:  Riemann hypothesis 

message: This is code from article
  function trouble(string s)
      if halt(s, s) = false
          return true
      else
          loop forever
but I think that correct form of trouble is( false replaced with true)
  function trouble(string s)
      if halt(s, s) = true
          return true
      else
          loop forever
: You are mistaken.  -- Dominus 20:38, 8 September 2005 (UTC)
thread_title:  Bad Proof?