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

On 2025-05-26 18:30:19 +0000, olcott said:

On 5/26/2025 1:19 PM, Fred. Zwarts wrote:

Op 26.mei.2025 om 18:14 schreef olcott:

On 5/26/2025 4:55 AM, Mikko wrote:

On 2025-05-25 14:32:14 +0000, olcott said:
 

On 5/25/2025 5:34 AM, Mikko wrote:

On 2025-05-24 17:15:50 +0000, olcott said:
 

On 5/24/2025 12:07 PM, Alan Mackenzie wrote:

olcott <polcott333@gmail.com> wrote:

On 5/23/2025 5:06 PM, Richard Heathfield wrote:

On 23/05/2025 22:06, olcott wrote:

On 5/23/2025 3:50 PM, Richard Heathfield wrote:

On 23/05/2025 21:24, olcott wrote:

 

<snip>

 

Liar

 

An unequivocal response, but it lacks persuasive power.

 

When I provide the exact detailed steps of exactly how
people can show that I am wrong and they refuse to
show that I am wrong yet claim that I am wrong this
is the kind of reckless disregard for the truth that
loses defamation cases.

 

When your opponents point to the Turing proof that proves you're wrong

 

Without going through all of the detailed steps
that I present that is a reckless disregard for
the truth that loses defamation cases.

 There you are utterly wrong.  The Halting Theorem has been proven, thus
is true.  Anybody putting up a contrary argument must therefore be wrong.
 You might also put up a long winded argument why 2 + 2 = 5, and I would
dismiss this likewise, without bothering to follow your exact detailed
steps.
 You've also tried, without success, to dismiss one of the proofs of the
Halting Therem as invalid.

 And would be successful if people actually paid
attention to what I said.

 People are successfull in pointing out errors in what you say.

 When they point out errors it is always of this form:
"that is not the way that I memorized it".

 If you were not lying you could point at least one pointer to a such
message. But you can't.
 

They never ever show any actual errors in my reasoning.

 They do. For eample:
 On Sat, 24 May 2025 17:07:11 +0000, Alan Mackenzie wrote:

olcott <polcott333@gmail.com> wrote:

On 5/23/2025 5:06 PM, Richard Heathfield wrote:

On 23/05/2025 22:06, olcott wrote:

 

When your opponents point to the Turing proof that proves you're wrong

 

Without going through all of the detailed steps that I present that is
a reckless disregard for the truth that loses defamation cases.

 There you are utterly wrong.  The Halting Theorem has been proven, thus
is true.  Anybody putting up a contrary argument must therefore be
wrong.

 That shows an actual error in your reasoning. You can't show any actual
error in Alan Mackenzie'sreasoning above.
 

 void DDD()
{
   HHH(DDD);
   return;
}
 _DDD()
[00002192] 55             push ebp
[00002193] 8bec           mov ebp,esp
[00002195] 6892210000     push 00002192
[0000219a] e833f4ffff     call 000015d2  // call HHH
[0000219f] 83c404         add esp,+04
[000021a2] 5d             pop ebp
[000021a3] c3             ret
Size in bytes:(0018) [000021a3]
 The key mistake of the conventional halting problem proofs
is that they do not require the halt decider to report on
the actual behavior actually specified by the input.

 They do. The input is a pointer to memory. This memory includes DDD and all functions called by it directly and in directly, including the code of Halt7.c, which specifies the abort, which makes that the input specifies a halting program.
 

 When HHH(DDD) computes the mapping from its finite string
input to the behavior that it actually specifies,

 namely, a program that aborts and halts,
 

we see
that the emulated DDD will continue to call HHH(DDD) in

 finite
 

recursive emulation

 but unable to reach the emulated 'ret' instruction, because of a premature abort. So, its mapping is incorrect, because it does not find the behaviour that is actually specified. This bug makes that it is
 

never able to reach its own emulated
"ret" instruction final halt state.
 The recursive emulation invariant is that the emulated
DDD never reaches its own emulated "ret" instruction final
halt state,

 because it is aborted prematurely. This failure of HHH to reach the 'ret' instruction, does not change the specification in the input. It only shows that the programmer made a mistake when he coded the abort code.

 Counter-factual.

Nothing counter-factual in that paragraph.

DDD emulated by HHH1 calls HHH(DDD) and this call returns
DDD emulated by HHH calls HHH(DDD) and this call CANNOT POSSIBLY RETURN

That a call to HHH does not return is sufficient to conclude that
HHH is not a halt decider.
--
Mikko