Re: Bad faith and dishonesty

Op 26.mei.2025 om 04:22 schreef olcott:

On 5/25/2025 9:00 PM, Mike Terry wrote:

On 25/05/2025 21:30, olcott wrote:

On 5/25/2025 3:05 PM, dbush wrote:

On 5/25/2025 3:56 PM, olcott wrote:

*Mike understood this perfectly*
On 5/14/2025 7:36 PM, Mike Terry wrote:
--------- Sipser quote -----
    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.
----------------------------
>
we can easily interpret that as saying exactly what I said a SHD
does above.  It tells PO that in the tight loop example, H correctly
simulates as far as [A], at which point it correctly determines that
"its simulated input would never stop running unless aborted", so
it can decide "non-halting".
>
All correct and natural, and no deliberately
false premises to mislead PO.
>
On 5/14/2025 7:36 PM, Mike Terry wrote:
https://al.howardknight.net/? STYPE=msgid&MSGI=%3C1003cu5%242p3g1%241%40dont-email.me%3E

>
And you dishonestly left out the part that immediately follows where he states that you are wrong:
>

>
*VERFIED FACT*
Mike Terry Proves ---
How the requirements that Professor Sipser agreed to are exactly met

>
Just for the record:
>
1)  I didn't offer any proofs of /anything/
>
-  I did explain how Sipser's words can be naturally interpreted as explaining
    how a simulating halt decider can operate.  [That is not a proof.]
>

 It seems like proof to me.
When-so-ever anyone provides complete and correct reasoning
showing how an expression of language is true, this is a proof.
 

-  I also explained why that explanation *doesn't* apply to your HHH/ DDD pair
>

 Yes you did do this.
 *On 5/14/2025 7:36 PM, Mike Terry wrote*
the simulated input (DD) /does/ stop running if simulated
far enough, but HHH simply /doesn't/ go far enough
 _DDD()
[00002192] 55             push ebp
[00002193] 8bec           mov ebp,esp
[00002195] 6892210000     push 00002192
[0000219a] e833f4ffff     call 000015d2  // call HHH
[0000219f] 83c404         add esp,+04
[000021a2] 5d             pop ebp
[000021a3] c3             ret
Size in bytes:(0018) [000021a3]
 I use the simpler DDD because everyone here gets
completely confused even by this simple example.
 How many recursive emulations does HHH have to
wait before its emulated DDD magically halts
on its own without ever needing to be aborted?
 Once you and I work through this one point I may
finally have complete closure.

Again you make the same mistake by not only changing the decider, but also the input.
We are discussing the input where DDD calls a HHH that aborts after one cycle.
This input needs a simulator that simulates at least two cycles, after which the simulation will end in a natural way.
But when we say that, you suddenly change the input to another one that needs three cycles. Changing the input is not allowed.
You caught yourself in this thinking by the way you constructed your DDD. It would be easier to see if DDD would be changed so that it did not call HHH, but included the code of HHH, so that simulator and input are in different places in memory.
You constructed a case where it is impossible to change the simulator without changing the input, which makes you very confused about what the input is.
Every competent programmer will see this, but you will probably just ignore it, or come with ad hominem attacks, or claim that it is a lie, only because you are dreaming of something else and reject everything that disturbs your dreams.