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

On 5/28/25 11:12 AM, 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.

Right, so that fact that you claim your HHH is actually deciding on a non-program and correctly decides on a version of that which differs from the program that it needs to be given to match the proof, just says yo are a liar.

 int DD()
{
   int Halt_Status = HHH(DD);
   if (Halt_Status)
     HERE: goto HERE;
   return Halt_Status;
}

Which isn't the program from the proof until you include in the program the decider it is proving wrong.

 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*

Nope, That isn't the question, so you again start with a lie.
The question is: WIll the program the input represents Halt when run?
The fact you start with the wrong question just shows you think strawmen are valid logic, and thus that you have straw for brains.

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

Nope, as that behavior, *IS* the behavior of the program the input represent when run.
The fact that your input doesn't actually fully represent a program means you are starting with a category error.

 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.
 

Right, and since *THE* defined HHH returns 0 from HHH(DD), that means that *THE* DD will get that 0 return and halt, and thus it doesn't NEED to be aborted.
The fact that a DIFFERENT DD, built on a DIFFERENT HHH acts differently is irrelevent, and you arument shows your utter stupidity, as bad as thinking that 1 is Red.