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

On 5/24/25 12:52 PM, olcott wrote:

On 5/24/2025 11:35 AM, Mike Terry wrote:

On 24/05/2025 01:36, Keith Thompson wrote:

Ben Bacarisse <ben@bsb.me.uk> writes:

Keith Thompson <Keith.S.Thompson+u@gmail.com> writes:

Ben Bacarisse <ben@bsb.me.uk> writes:
[...]

And the big picture is that this can be done because false is the
correct halting decision for some halting computations.  He has said
this explicitly (as I have posted before) but he has also explained it
in words:
>
| When-so-ever a halt decider correctly determines that its input would
| never halt unless forced to halt by this halt decider this halt
| decider has made a correct not-halting determination.

>
Hmm.  I don't read that the way you do.  Did I miss something?
>
It assumes that the input is a non-halting computation ("its input
would never halt") and asserts that, in certain circumstances,
his mythical halt decider correctly determines that the input
is non-halting.
>
When his mythical halt decider correctly determines that its input
doesn't halt, it has made a correct non-halting determination.
It's just a tautology.

>
It would be a tautology but for the "unless..." part.  It does not make
the determination that it does not halt.  It determines that it would
not halt were it not for the fact that the decider (a simulation) in
fact halts it.

>
Right, so the computation itself is non-halting.

>
No no no, it halts!  (Assuming we're discussing the computation DD() with PO's code.)
>

  int DD()
{
   int Halt_Status = HHH(DD);
   if (Halt_Status)
     HERE: goto HERE;
   return Halt_Status;
}
 _DD()
[00002162] 55             push ebp
[00002163] 8bec           mov ebp,esp
[00002165] 51             push ecx
[00002166] 6862210000     push 00002162
[0000216b] e862f4ffff     call 000015d2
[00002170] 83c404         add esp,+04
[00002173] 8945fc         mov [ebp-04],eax
[00002176] 837dfc00       cmp dword [ebp-04],+00
[0000217a] 7402           jz 0000217e
[0000217c] ebfe           jmp 0000217c
[0000217e] 8b45fc         mov eax,[ebp-04]
[00002181] 8be5           mov esp,ebp
[00002183] 5d             pop ebp
[00002184] c3             ret
Size in bytes:(0035) [00002184]
 It is a damned lie that DD simulated by HHH according
to the rules of the x86 language ever reaches its own
machine address 00002184 final halt state.

But that isn't the criteria that HHH is supposed to use.
So, you are just showing you are using a strawman.
And, it is just a damned lie that any HHH that returns an answer for that input actually did a correct simulation of the input.

 The input to HHH(DD) specifies a non-halting sequence
of configurations.

Nope, not if HHH(DD) returns 0.
Of course, you first have to fix DD to be a program that can be run by including the implied code of HHH as part of it.
WHich is what makes your argument a lie, as each HHH gets a differnt DD to look at.

 The above two are verified facts and anyone lying about
this may be condemned to actual Hell.
At least that is what Revelations 21:8 says.
 

Nope, those are verified LIES, based on the facts.
Sorry, you are just showing how bad your logic is, and how little you know of the topic you are trying to talk about.