Re: How do computations actually work?

Op 23.mei.2025 om 20:19 schreef olcott:

On 5/23/2025 1:03 PM, Fred. Zwarts wrote:

Op 23.mei.2025 om 19:00 schreef olcott:

On 5/23/2025 11:16 AM, Richard Damon wrote:

On 5/23/25 12:10 PM, olcott wrote:

On 5/23/2025 2:14 AM, Mikko wrote:

On 2025-05-23 03:31:15 +0000, olcott said:
>

On 5/22/2025 10:23 PM, wij wrote:

On Thu, 2025-05-22 at 21:47 -0500, olcott wrote:

[cut]

>
Q: How do computations actually work?
A: Computation is merely step-by-step algorithm.
Nothing says it has to be TM.
>
Do the exercises in textbooks first before any claim of it.
>

>
int main()
{
   DD(); // by what steps can the HHH that DD calls
}       // report on the behavior its caller?

>
If we don't insist that the report be correct:
1. guess
2. tell what was guessed
>

>
This does not work because all computable functions
that implement termination analyzers must compute
the mapping from their input finite string according
to the behavior that it specifies. In my concrete
examples DDD must be simulated by HHH according to the
rules of the x86 language.
>
_DDD()
[00002172] 55         push ebp      ; housekeeping
[00002173] 8bec       mov ebp,esp   ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404     add esp,+04
[00002182] 5d         pop ebp
[00002183] c3         ret
Size in bytes:(0018) [00002183]
>
DDD specifies that it will continue to call HHH
until HHH sees the repeating pattern and aborts
its simulation.
>

>
Yes, they must compute the mapping, but the rules don't say HOW.

>
*They never bothered to say HOW until NOW*
The ultimate definition of a correct simulation
is a simulation according to the definition of
the simulation language.
>
One is not free to interpret "push ebp" as "jmp 00002183".
>

>
And one is not free to halt the simulation and ignore the halting behaviour specified in the remainder of the input, because it is against the rules of the simulation language.

 _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]
 Show me how DDD correctly simulated by HHH
reaches its own "ret" instruction.

What HHH should do, is what HHH1 does. But HHH cannot do that, because it has a bug that makes it to abort the simulation before it can see that the input specifies a halting program.
In fact, no HHH can simulate itself. Therefore the question to show a correct HHH is invalid. Is that too difficult to understand?
I cannot correct your HHH, because your HHH does what *you* coded. I cannot change *your* code. It is *your* task to remove errors in the code, not mine. I only tell you, that you spoil your time with it, because no such HHH exists.
HHH should be based on facts, not on dreams. If no such HHH exists, then dreaming about one does not help.

 You won't do this because you know that you
are a damned liar.
 

As usual, ad hominem attacks are use to hide the fact that there is no counter argument.