Re: Bad faith and dishonesty

On 5/25/25 4:30 PM, 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

Nope.
You don't understand what he said.

 

PO's problem is his misinterpretation of "its simulated input would never stop running unless aborted".

 

In the case of his HHH/DD, the simulated input (DD) /does/ stop running if simulated far enough, but

 Ridiculously COUNTER-FACTUAL

FACTUAL.
The CORRECTLY simulated DD does.
The PARTIAL simulation by HHH doesn't, but being partial isn't correct.

 void DDD()
{
   HHH(DDD);
   return;
}
 At exactly what point does DDD simulated by
HHH reach its simulated "return" statement?
Would a googolplex of simulations be enough?

It doesn't need to, if HHH aborts its simulation, which it DOES.

 _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]
 After a googolplex of simulations does HHH get
tired and say screw it I am going to interpret
"push ebp" as "jmp 000021a3" ?

But that isn't what HHH does.
HHH, by your stipulations is a decider, and thus MUST abort to return, and thus the correct simulation of DD will halt.
In fact, by your other stipulations, DDD doesn't include the code of HHH, so HHH can't simulate the input past the call, because it isn't part of the input, which is all that "simulating the input" can look at.
Note, the DDD that uses the HHH that doesn't abort is a DIFFERENT input, as DDD, to be a program and be simulatable, MUST include the code of that HHH, which it doesn't, but when it does, every HHH sees a DIFFERENT DDD, so it is just a lie to try to look at one to determine the behavior of another.

 

HHH simply /doesn't/ go far enough because PO has mistakenly decided he's seen some pattern that implies non-halting in the trace.  [A pattern akin to the "tight loop" pattern, except that the tight loop pattern is sound, while his pattern is unsound, matching on a halting input. Simples!]

>
>
This proves, as you yourself said:
>
On 5/25/2025 3:04 PM, olcott wrote:
 > You Are the epitome of bad faith and dishonesty.
 > This may cost you your actual soul: Revelations 21:8.
>
>
>