Re: Peter Olcott seems to consistently lie about this

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.
>

 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.
 

Except that you hypotesize with fussy words, and thus break the procedure.
IF "Correct simulation" means, as normal, one that runs to completion, then the statement is true, but any HHH that does abort isn't given the input that was proven to not abort, as the HHH that DDD calls is part of it.
IF "Correct Simulation" means, as you claim, that it can be partial, then the statement is just incorrect, the partial simulation may not reach the return, but the program that was being simulated, continues after that aborting, and reaches the point, and thus the statment isn't true.
Part of your problem is you confuse the partial simulation of a program with the behavior of that program, which is defined as it COMPLETE behavior, and thus not shown by a partial simulation of it.
THis matches your confusion between truth and knowledge, and you total lack of knowledge about most of what you talk about.
Sorry, you are just proving yourself to be a pathological liar.