Re: Petyer Olcott seems to consistently lie about this

On 8/6/24 8:12 AM, olcott wrote:

On 8/6/2024 6:54 AM, Richard Damon wrote:

On 8/6/24 7:35 AM, olcott wrote:

On 8/6/2024 3:07 AM, Mikko wrote:

On 2024-08-05 12:45:11 +0000, olcott said:
>

On 8/5/2024 2:27 AM, Mikko wrote:

On 2024-08-04 12:33:20 +0000, olcott said:
>

On 8/4/2024 2:15 AM, Mikko wrote:

On 2024-08-03 13:48:12 +0000, olcott said:
>

On 8/3/2024 3:06 AM, Mikko wrote:

On 2024-08-02 02:09:38 +0000, olcott said:
>

*This algorithm is used by all the simulating termination analyzers*
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
     If simulating halt decider H correctly simulates its input D
     until H correctly determines that its simulated D would never
     stop running unless aborted then
>
     H can abort its simulation of D and correctly report that D
     specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
>
DDD is correctly emulated by HHH according to the x86
language semantics of DDD and HHH including when DDD
emulates itself emulating DDD
>
*UNTIL*
>
HHH correctly determines that never aborting this
emulation would cause DDD and HHH to endlessly repeat.

>
The determination is not correct. DDD is a halting computation, as
correctely determined by HHH1 or simly calling it from main. It is
not possible to correctly determine that ha haling computation is
non-halting, as is self-evdent from the meaning of the words.
>

>
[Who here is too stupid to know that DDD correctly simulated
  by HHH cannot possibly reach its own return instruction?]

>
Who here is too stupid to know that whether DDD can reach its
own return instruction depends on code not shown below?
>

>
void DDD()
{
   HHH(DDD);
   return;
}
>
It is stipulated that HHH is an x86 emulator the emulates
N instructions of DDD where N is 0 to infinity.

>
That is not stipulated above. Anyway, that stipulation would not
alter the correctness of my answer.
>

>
typedef void (*ptr)();
int HHH(ptr P);
>
void DDD()
{
   HHH(DDD);
   return;
}
>
int main()
{
   HHH(DDD);
}
>
In other words you do not know C well enough to comprehend
that DDD correctly simulated by any HHH cannot possibly reach
its own "return" instruction halt state.

>
You are lying again.
that

>
I am hypothesizing. If you do know C well enough to agree then
simply agree. What I said is a tautology thus disagreement <is> error.
>

>
And, if it *IS* a tautoligy, then you agree that "Correct Simulation" means a simulation that doesn't abort,

 Your attention deficit order continues to cause you to forget
most of the details that I told you hundreds of times.
 A correct emulation of 0 to infinity lines of DDD is
a correct emulation of 0 to infinity lines of DDD.

But a correct emulation of a finite number of steps of DDD is not a correct emulaiton of DDD. THe former ADMITS to being incomplete, while the later claims to be complete.

 A correct simulation of N lines of DDD is sufficient to
determine that no correct simulation of DDD by any HHH
will ever stop running unless aborted.
 

Nope, that is proven wrong by HHH1. HHH says that the simulation of the input of DDD calling HHH doesn't halt, but HHH1' complete emulation of tha tinput shows that it does.
If you want to claim that these differ, what is the first instruction actually correctly emulated per the definition of the x86 instruction set (so a call HHH goes into the x86 instructions of the function HHH) differed in their behavior, and why?
Failure to answer just admits that this is a lie.
Note, this HAS been asked before, and you haven't show the difference, so you HAVE admitted that this claim is just a lie.
You just don't understand what you are talking about, and thus trap yourself in your lies.