Re: Analysis of Flibble’s Latest: Detecting vs. Simulating Infinite Recursion ZFC

On 2025-05-28 17:33:53 +0000, olcott said:

On 5/28/2025 12:26 PM, Richard Heathfield wrote:

On 28/05/2025 16:51, olcott wrote:

On 5/28/2025 10:23 AM, Richard Heathfield wrote:

On 28/05/2025 16:12, olcott wrote:

On 5/28/2025 4:44 AM, Richard Heathfield wrote:

On 28/05/2025 09:02, Mikko wrote:

On 2025-05-28 07:46:42 +0000, Richard Heathfield said:
 

On 27/05/2025 22:25, olcott wrote:

On 5/27/2025 8:11 AM, Richard Heathfield wrote:

On 27/05/2025 11:41, Fred. Zwarts wrote:
 <snip>
 

Of course HHH can be called by any other function even by DDD.

 And is. DDD's source shows this.
 

But that is completely irrelevant

 Not in my view.
 I accept that that's your view and I won't dispute it because I understand your reasoning, but you and I are talking about different things. My underlying point is quite simply that Olcott made an incorrect and indeed contradictory claim about what HHH can and cannot report on. At the very, *very* least he made an insufficiently qualified claim.
 

 int sum(int x, int y) { return x + y; }
HHH must report on the behavior that its input actually
specifies the same way that sum(3,4) must report on the
sum of 3 + 4.

 DDD calls HHH, and you have said: "No HHH can report on the behavior of its caller" - so HHH cannot report on DDD.
 HHH's input is DDD, and you have said: "HHH must report on the behavior that its input actually specifies" - so HHH must report on DDD.
 Cannot/must.
 Must/cannot.
 Surely you don't really expect us to take you seriously?

 Why not? The point of the halting theorem is that a halting decider
cannot do what it must do. HHH is an example of that.

 It is, but I'm not sure that Mr O will see it that way.
 

 We can equally say that sum(3,4) must provide the sum of 5 + 6
and we would be wrong.

 You have arrived at two contradictory requirements for your system. Therefore, somewhere along the line you have made an incorrect assumption.
 5 + 6 isn't it.
 

 int DD()
{
   int Halt_Status = HHH(DD);
   if (Halt_Status)
     HERE: goto HERE;
   return Halt_Status;
}
 In the conventional halting problem proof the answer
to the question:
 What correct Boolean value can HHH(DD) return to
indicate the actual halt status of its input?
*BOTH BOOLEAN RETURN VALUES ARE INCORRECT*

 Not so.
 The Halting Problem only says that if HHH is a universal halting decider, which it clearly isn't.
 

 In the conventional HP proof both Boolean
return values ARE THE WRONG ANSWER.

 Only if you have a universal halting decider, which you don't.
 

When we understand that a STA must report on the
behavior that its input actually specifies we get
a different result.

 When you understand that you can't flannel your way past your mutually contradictory requirements and recognise that they indicate a break in your reasoning, we should get a different result.
 

It is a tautology that every input to a simulating
termination analyzer would never stop running unless
aborted specifies a non-terminating sequence of
configurations thus HHH(DD) == 0 is correct.

 That's not the issue right now.
 

 It is 100% of the whole issue.

 Well, no. If anything, it raises a new issue (or at least an issue I have yet to see you address), which is how you hope to distinguish between a computation that never terminates and a computation that does terminate after a very long time.

 I am not solving the halting problem.
Instead I proved that the conventional proof is wrong.

You haven't done that, either. The nearest is that you have falsely
claimed to have proven that.
All "conventional" proofs are merely adaptations of Turing's proof.
What honest purpose could it serve if you would prove some "conventional"
proof wrong?
--
Mikko