On 3/18/25 11:44 PM, olcott wrote:
On 3/18/2025 10:16 PM, Richard Damon wrote:
On 3/18/25 10:16 PM, olcott wrote:
On 3/18/2025 5:28 AM, joes wrote:
Am Mon, 17 Mar 2025 22:43:05 -0500 schrieb olcott:
On 3/17/2025 8:19 PM, Richard Damon wrote:
On 3/17/25 3:58 PM, olcott wrote:
On 3/17/2025 2:50 PM, Fred. Zwarts wrote:
Op 17.mrt.2025 om 20:41 schreef olcott:
It is impossible for one TM X to determine that another TM Y has >>>>>>>>> only an infinite loop on the basis of the direct execution of >>>>>>>>> Y. No
TM can in any way monitor the direct execution of another TM. >>>>>>>>>
No, of course it cannot monitor.
Then it cannot possibly compute the mapping from the directed
executed
TM to its behavior and everyone saying this <is> the basis for the >>>>>>> halting problem is wrong.
And what is wrong about it not being able to compute that?
It means that everyone saying that the behavior must be the
behavior of
the direct execution is wrong.
The behavior that HHH reports on can only be the behavior that HHH can >>>>> see.
If only it would simulate correctly... then it would see.
Nothing requires that the decider actually be able to do the
computation, the failure to do so just make the decider incorrect, >>>>>> which is an option.
It is always impossible for any halt decider to directly report on the >>>>> actual behavior of the direct execution of any other TM. Most of the >>>>> time the halt decider lucks out and the behavior specified by the
finite
string works as a proxy for the behavior of the direct execution.
lolno.
void DDD()
{
HHH(DDD);
return;
}
If you think that DDD correctly simulated by HHH
that includes HHH correctly simulating itself
simulated DDD reaches its return instruction
How the F-ck does it do this?
But your HHH, as defined by the Halt7.c
_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]
Does emulate the first four instructions of DDD
and HHH emulating itself emulating DDD reaching
the machine address of 0000217a a second time.
Right, and it was the conditional instruction in that "loop", so it
knows that the HHH that it is simulating can abort its simulation and
return,
Then HHH correctly determines that there are no
conditional branch instructions between 00002172
and 0000217a and that DDD called the same function
twice in sequence.
But that doesn't matter, as you are basing your claim on an incorrect
rule. The actual rule refers to no conditionals between the two calls.
Since you can't (or won't as it reveals the lie) show where you got your "rule", you are just admitting that your whole logic is based on LIES,
and is thus just a FRAUD.
The closest I can think of to your "rule" requires that HHH be a
function that DOES correctly emulate its input until it reaches a final
state, which HHH doesn't do, since it abort its emulation.
It seems you don't understand that partial emulation is not correct
emulation, perhaps because you don't understand the logical definition
of "Correct" to be an absolute, and not just mostly correct.
Sorry, you seem to be so stupid you can't learn from your own mistakes
when they are pointed to you, and thus you are doomed to repeat them
FOREVER, through all of eternity.
--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)