Re: Everyone here seems to consistently lie about this

On 2024-08-07 13:14:13 +0000, olcott said:

On 8/7/2024 2:12 AM, Mikko wrote:

On 2024-08-06 11:35:51 +0000, olcott said:
 

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.

 You were and still are lying. There was no word (such as "assume") in
your calim about me, so it was not a hypothesis but a lie.
 

 Several of your answers seemed to show that you did not
know C very well. Fred and Joes did not seem to know
programming very well.

According to our defamation laws "seemed" is not sufficinet to ensure
that you aren't jailed.
--
Mikko