XPost: comp.theory, sci.logic
On 6/10/25 12:17 PM, olcott wrote:
On 6/10/2025 11:09 AM, Mike Terry wrote:
On 10/06/2025 12:41, Mikko wrote:
On 2025-06-10 00:47:12 +0000, olcott said:
On 6/9/2025 7:26 PM, Richard Damon wrote:
On 6/9/25 10:43 AM, olcott wrote:
On 6/9/2025 5:31 AM, Fred. Zwarts wrote:
Op 09.jun.2025 om 06:15 schreef olcott:
On 6/8/2025 10:42 PM, dbush wrote:
On 6/8/2025 11:39 PM, olcott wrote:
On 6/8/2025 10:32 PM, dbush wrote:
On 6/8/2025 11:16 PM, olcott wrote:
On 6/8/2025 10:08 PM, dbush wrote:
On 6/8/2025 10:50 PM, olcott wrote:
void DDD()
{
HHH(DDD);
return;
}
The *input* to simulating termination analyzer HHH(DDD) >>>>>>>>>>>>>
No it's not, as halt deciders / termination analyzers work >>>>>>>>>>>>> with algorithms,
That is stupidly counter-factual.
That you think that shows that
My understanding is deeper than yours.
No decider ever takes any algorithm as its input.
But they take a description/specification of an algorithm,
There you go.
which is what is meant in this context.
It turns out that this detail makes a big difference.
And because your HHH does not work with the description/
specification of an algorithm, by your own admission, you're >>>>>>>>> not working on the halting problem.
HHH(DDD) takes a finite string of x86 instructions
that specify that HHH simulates itself simulating DDD.
And HHH fails to see the specification of the x86 instructions.
It aborts before it can see how the program ends.
This is merely a lack of sufficient technical competence
on your part. It is a verified fact that unless the outer
HHH aborts its simulation of DDD that DDD simulated by HHH
the directly executed DDD() and the directly executed HHH()
would never stop running. That you cannot directly see this
is merely your own lack of sufficient technical competence.
And it is a verified fact that you just ignore that if HHH does in
fact abort its simulation of DDD and return 0, then the behavior of
the input, PER THE ACTUAL DEFINITIONS, is to Halt, and thus HHH is
just incorrect.
void DDD()
{
HHH(DDD);
return;
}
How the f-ck does DDD correctly simulated by HHH
reach its own "return" statement final halt state?
If HHH is not a decider the question is not interesting.
If HHH is a deider it returns. The first insturunction
after the return terminates the execution of DDD.
But then DDD *simulated by HHH* does is not simulated as far as its
own return statement. In fact zero steps of DDD are simulated.
Since I have shown you the execution trace of DDD simulated
by HHH many times it is gross negligence that you say that
"zero steps of DDD are simulated."
Since all your traces show that HHH just doesn't correctly simulate a
call instruction, all you are doing is proving your whole arguement is a
LIE.
The *ONLY* correct simulation of the byte sequence at 0000217A of
E8 53 F4 FF FF would be for current PC to be pushed onto the stack, and
the next instruction at 000015D2 to be the simulated
Since that isn't what happens, you are just showing that you are just a
bit fat liar.
Please show where in the x86 instruction language you have any
justification for your traces.
This has been asked before, many times, and your failure to reply just
shows that you KNOW you are just LYING about this, and hope to cover it
with a smoke screen.
_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]
_main()
[00002192] 55 push ebp
[00002193] 8bec mov ebp,esp
[00002195] 6872210000 push 00002172 ; push DDD
[0000219a] e833f4ffff call 000015d2 ; call HHH(DDD)
[0000219f] 83c404 add esp,+04
[000021a2] 50 push eax
[000021a3] 6843070000 push 00000743
[000021a8] e8b5e5ffff call 00000762
[000021ad] 83c408 add esp,+08
[000021b0] 33c0 xor eax,eax
[000021b2] 5d pop ebp
[000021b3] c3 ret
Size in bytes:(0034) [000021b3]
machine stack stack machine assembly
address address data code language
======== ======== ======== ========= ============= [00002192][00103820][00000000] 55 push ebp ; Begin main()
[00002193][00103820][00000000] 8bec mov ebp,esp ; housekeeping
[00002195][0010381c][00002172] 6872210000 push 00002172 ; push DDD [0000219a][00103818][0000219f] e833f4ffff call 000015d2 ; call HHH(DDD)
New slave_stack at:1038c4
Begin Local Halt Decider Simulation Execution Trace Stored at:1138cc [00002172][001138bc][001138c0] 55 push ebp ; housekeeping
[00002173][001138bc][001138c0] 8bec mov ebp,esp ; housekeeping
[00002175][001138b8][00002172] 6872210000 push 00002172 ; push DDD [0000217a][001138b4][0000217f] e853f4ffff call 000015d2 ; call HHH(DDD)
New slave_stack at:14e2ec
[00002172][0015e2e4][0015e2e8] 55 push ebp ; housekeeping
[00002173][0015e2e4][0015e2e8] 8bec mov ebp,esp ; housekeeping
[00002175][0015e2e0][00002172] 6872210000 push 00002172 ; push DDD [0000217a][0015e2dc][0000217f] e853f4ffff call 000015d2 ; call HHH(DDD)
Local Halt Decider: Infinite Recursion Detected Simulation Stopped
[0000219f][00103820][00000000] 83c404 add esp,+04 [000021a2][0010381c][00000000] 50 push eax [000021a3][00103818][00000743] 6843070000 push 00000743 [000021a8][00103818][00000743] e8b5e5ffff call 00000762
Input_Halts = 0
[000021ad][00103820][00000000] 83c408 add esp,+08 [000021b0][00103820][00000000] 33c0 xor eax,eax [000021b2][00103824][00000018] 5d pop ebp [000021b3][00103828][00000000] c3 ret
Number of Instructions Executed(10069) == 150 Pages
Of course, DDD directly executed will reach its own return statement,
so it is true that this DDD halts...
Likewise if you twin brother robbed a liquor store
this make you yourself guilty because you look the
same as him.
And where does THAT come into the picture?
Or, do you think that just because YOU committed the crime, but you can
get some people to say your evil twin bother did it, that you can get
off scott free.
Sorry, you are just nailing the coffin on your reputation with your
assertions admitting to your errors.
Mike.
--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)