Re: Who here understands that the last paragraph is Necessarily true?

Op 20.jul.2024 om 16:54 schreef olcott:

On 7/20/2024 4:39 AM, Mikko wrote:

On 2024-07-19 14:43:53 +0000, olcott said:
>

On 7/19/2024 4:02 AM, Mikko wrote:

On 2024-07-16 18:26:12 +0000, olcott said:
>

On 7/16/2024 3:16 AM, Mikko wrote:

On 2024-07-15 13:51:14 +0000, olcott said:
>

On 7/15/2024 3:37 AM, Mikko wrote:

On 2024-07-15 03:41:24 +0000, olcott said:
>

On 7/14/2024 9:04 PM, Richard Damon wrote:

On 7/14/24 9:27 PM, olcott wrote:

>
Any input that must be aborted to prevent the non termination
of simulating termination analyzer HHH necessarily specifies
non-halting behavior or it would never need to be aborted.

>
Excpet, as I have shown, it doesn't.
>
Your problem is you keep on ILEGALLY changing the input in your argument because you have misdefined what the input is.
>
The input to HHH is ALL of the memory that it would be accessed in a correct simulation of DDD, which includes all the codd of HHH, and thus, if you change HHH you get a different input.
>
If you want to try to claim the input is just the bytes of the function DDD proper then you are just admitting that you are nothing more than a lying idiot that doesn't understand the problem,

Turing machines only operate on finite strings they do
not operate on other Turing machines *dumbo*

>
That's right. But the finite string can be a description of a Turing machine.

>
No that is wrong. The finite string must encode a Turing machine.

>
That you agree does not mean that it is wrong.
>

>
Your ignorance that a Turing machine cannot take its own
executing self as an input is no rebuttal what-so-ever.

>
You should not assume that everyone is as stupid as you.
>

>
That all rebuttals to my work have one fatal flaw or
another is beyond the comprehension of my reviewers
provides zero evidence that these rebuttals are not flawed.

>
You can claim that the indications of flaws of your "work" are flawed
but that does not remove the indicated flaws from your work.
>

 Every rebuttal of my work denies a tautology
proving that the rebuttal is incorrect because
all tautologies are necessarily true.
 int main()
{
   DDD();
}
 Calls HHH(DDD) that must abort the emulation of its input
or {HHH, emulated DDD and executed DDD} never stop running.
 *The above is a Tautology*
 

It is not, because the input is the same HHH that aborts and halts, so its simulation halts when it is not aborted.
DDD is a misleading and unneeded complication. It is easy to eliminate DDD:
        int main() {
          return HHH(main);
        }
This has the same problem. This proves that the problem is not in DDD, but in HHH, which halts when it aborts the simulation, but it decides that the simulation of itself does not halt.
HHH is simply unable to decide about finite recursions.
void Finite_Recursion (int N) {
   if (N > 0) Finite_Recursion (N - 1);
}
It decides after N recursions that there is an infinite recursion, which is incorrect.
Olcott's HHH is programmed to abort the simulation after N cycles of recursive simulations. Therefore, it is incorrect to abort the simulation of HHH when the simulated HHH has performed only N-1 cycles, because that skips the real behaviour of HHH.
Since the simulated HHH always runs one cycle behind the simulating HHH, it is clear that HHH can never simulate enough cycles for a correct simulation, as is required by the x86 language.
Therefore, the simulation is incorrect according to the criteria olcott stipulated.
The conclusion is simple:
HHH cannot possibly simulate itself correctly.
No matter how much olcott wants it to be correct, or how many times olcott repeats that it is correct, it does not change the fact that such a simulation is incorrect, because it is unable to reach the end.
Olcott's own claim that the simulated HHH does not reach its end confirms it. The trace he has shown also proves that HHH cannot reach the end of its own simulation. So, his own claims prove that it is true that HHH cannot possibly simulate itself up to the end, which makes the simulation incorrect.
Sipser would agree that this incorrect simulation cannot be used to detect a non-halting behaviour.
Olcott could not point to an error, but prefers to ignore it. So, I will repeat it, until either an error is found, or olcott admits that HHH cannot possibly simulate itself correctly.