Re: How do computations actually work?

On 5/27/25 11:48 AM, olcott wrote:

On 5/27/2025 3:37 AM, Mikko wrote:

On 2025-05-26 15:57:11 +0000, olcott said:
>

On 5/26/2025 3:46 AM, Mikko wrote:

On 2025-05-25 14:53:06 +0000, olcott said:
>

On 5/25/2025 4:14 AM, Mikko wrote:

On 2025-05-24 15:18:57 +0000, olcott said:
>

On 5/24/2025 2:47 AM, Mikko wrote:

On 2025-05-23 02:47:40 +0000, olcott changed the subject to

How do computations actually work?

>
Each computation works differently. It does not matter how it works as
long as there are instructions that fully specify how that computation
shall be performed.

>
All termination analyzers are required to report on the
behavior that their input finite string specifies.

>
To report correctly. Though the input string to a termination analyzer
usially is incomlete: the input string usually specifies different
behavours depending on the input that is not shown to the termination
analyzer, and the analyzer's report must cover all of them.
>
A partial termination analyzer may fail to report but is not allowed
to report incorrectly.

>
void DDD()
{
   HHH(DDD);
   return;
}
>
DDD simulated by HHH cannot possibly reach its
"return" statement final halt state, only liars
will disagree.

>
Again a straw man deception. Where reasonable people disgraee is the
relevance of that claim. The behavour specified by DDD does reach the
final return from DDD. Whether HHH can simulate that part of the
behaviour is irrelevant. Even without the simjlation HHH decides
correctly if and only if it determines and reports that DDD halts.

>
_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]
>
How many recursive emulations does HHH have to
wait before its emulated DDD magically halts
on its own without ever needing to be aborted?

>
In order to determine that you need a program that simulates DDD and all
functios DDD calls and detects and counts and reports emulation levels.
>

 No you don't. All that you need to do is simply imagine
that HHH is an x86 emulator capable of emulating itself
emulating DDD. // *This is fully operational code*

But then it gets a DIFFERENT DDD, and that HHH never answers.

 We are leaving the number of steps that it emulates up to
you. How many steps will it take for the simulated DDD to
reach its own simulated "ret" instruction final halt state?
 

But if HHH is defined to be a correct emulator, then we can show that THAT DDD, the DDD that calls the correct emulator, will be non-halting, just as we can show that the DDD that calls a decider that returns 0 for this input will be halting.
You don't seem to understand that 1 is not 2.