Re: Everyone on this forum besides Keith has been a damned liar about this point

On 6/11/25 9:55 AM, olcott wrote:

On 6/11/2025 7:38 AM, Fred. Zwarts wrote:

Op 10.jun.2025 om 19:25 schreef olcott:

On 6/10/2025 3:49 AM, Fred. Zwarts wrote:

Op 09.jun.2025 om 16:39 schreef olcott:

On 6/9/2025 5:26 AM, Fred. Zwarts wrote:

Op 09.jun.2025 om 06:04 schreef olcott:

On 6/8/2025 10:54 PM, Keith Thompson wrote:

olcott <polcott333@gmail.com> writes:

On 6/8/2025 10:31 PM, Keith Thompson wrote:

olcott <polcott333@gmail.com> writes:

void DDD()
{
    HHH(DDD);
    return;
}
>
The *input* to simulating termination analyzer HHH(DDD)
specifies recursive simulation that can never reach its
*simulated "return" instruction final halt state*
>
*Every rebuttal to this changes the words*

Do not imply that I support your claims.

>
I am not implying anything. I am directly stating
that you have agreed that when DDD is correctly simulated
by HHH that it cannot possibly reach its own simulated
"return" instruction and terminate normally.

>
Endless recursion is endless recursion.  Correctly simulated endless
recursion is endless recursion.

>
Great. No one else besides you and I agree that DDD
correctly simulated by HHH cannot possibly reach its
*simulated "return" instruction final halt state*

>
Nobody denied it. You are fighting windmills.
We all agree that your HHH fails to reach the end of the simulation of the input. An input that specifies a halting program, but HHH cannot simulate it.
>

>

 This has no useful or interesting
consequences.  Do you agree?
>

>
It is very useful because it is isomorphic to this:
(The standard Halting Problem counter-example input)
>
int DD()
{
   int Halt_Status = HHH(DD);
   if (Halt_Status)
     HERE: goto HERE;
   return Halt_Status;
}
>

>
Indeed, it shows that simulation is not the right way to try to refute the proof of the halting theorem, because a simulator will never be able to simulate itself correctly up to the end.
>

>
It is ridiculously stupid to require a non-terminating
input to be simulated up to its non-existent end.
>

>
It is even more stupid to ignore the halting part of the input (with a premature abort) and claim it is not halting.

>
It waiting forever is not long enough (and it is)
then your idea about "premature abort" is incorrect.

>
Running one more cycle is enough to see the simulated abort (unless you change the input to another input specifying another program that needs again another cycle. That other input is only in your dream. The input specified in Halt7.c is the input we discuss.
>

 So you aren't bright enough to understand that
infinite recursion does not halt on its own.

But the recursion isn't infinite for any of the HHH's that you claim to get the right answer.
Your problem is you forget that youy

 HHH waits until it sees that its input calls the same
function with the same parameters twice in sequence
with no conditional branch inbetween the beginning
of DDD and its call to HHH(DDD). It does not matter
that there are conditional branch instructions in HHH
because they cannot be reached and none of them could
possibly enable DDD simulated by HHH to reach its own
"return" statement final halt state.

Which is NOT a correct non-halting condition, and those conditional branches DO matter.
I guess you are just admitting that HHH doesn't actually do a correct simulation of the input, as the input, to be correctly simulated needs to include the code of the HHH that it calls, and thus the simulation of the input WILL reach those conditional branches.

 The outermost HHH sees this infinite recursion behavior
pattern one whole recursive emulation before the next
inner one. Because each instance of HHH has the same
machine code unless the outmost one aborts none of them
abort. If the outermost HHH waits on the inner one then
they all wait and the abort never occurs.

No, it sees the INCORRECT pattern created by the idiot that programmed it that has shown that he believes his own lies.
Yes, we have two cases:
1) NO HHH has code to abort, and thus HHH gets trapped in an infinite loop and never answers, and thus fails to be a decider.
2) EVERY HHH has code to abort, and WILL abort, and thus every DDD will be halting as every HHH WILL return to its caller and that will return.
Your problem is you lied to yourself about what the question that HHH needs to be answered, because you chose to make yourself stupid about the topic, and you beleived your own lie.

 Unless HHH(DDD) aborts the simulation of its input
DDD simulated by HHH, the directly executed DDD() and
the directly executed HHH() NEVER STOP RUNNING.

Right, but since it does, so does the directly executed DDD (which isn't aborted by anthing, since it can't be)
Your logic could only work if HHH could be two different programs at once, which it can't be, except in a fantasy world that accepts lies, as it seems the world you live in does.

 I have told you this many times and you just aren't
bright enough to understand. That you are ignorant
DOES NOT MAKE ME INCORRECT, IT MAKES YOU INCORRECT.

No, *YOU* are the ignorant one, as has been explained, and you are using LIES as your definitions, and that DOES make you incorrect.
Sorry, you are just showing that you really are that stupid.
Your failure to even try to respond to the errors pointed out in your statements (except by just repeating the error) just shows that you don't have the intelegence to understand your errors.

 

>
That you do not understand that unless the outermost
HHH aborts that no HHH ever aborts is your mistake
not mine.
>
>

>
That you do not see that one more cycle is enough, because you keep changing the input to something you dream about but is not the actual input is your problem, not mine.