On 8/8/25 10:42 AM, olcott wrote:
On 8/8/2025 1:11 AM, Richard Heathfield wrote:
On 08/08/2025 00:41, Richard Damon wrote:
On 8/7/25 8:54 AM, olcott wrote:
<snip>
OK we are finally getting somewhere.
The question really never has been does DDD() halt.
The question has always been: Does the input to HHH(DDD)
specify a halting sequence of configurations?
No, the Halting Problem has ALWAYS been about does DDD halt.
Yet when we reform this into a concrete simulating
termination analyzer:
But you aren't allowed to change the problem, and still claim to be
doing the problem.
It may be very difficult to understand, yet the behavior
of non-inputs does not count. Simulating termination
analyzers are only accountable for the behavior that their
inputs specify.
Except that it isn't a "non-input", it is the semantic meaning of the input.
Correct simulation is a correct measure of this behavior.
Correct simulation and direct execution only vary when
an input calls its own simulating termination analyzer.
In the case it is the input that rules and non-inputs are
irrelevant.
And "Correct Simulaition" is DEFINED to produce the same behavior as
direct execution.
Sorry, you are just trying to claim the right to lie.
Precisely. And even a cursory inspection of the code reveals that HHH
doesn't have enough information to make that call by simulation,
because it has to halt before it gets that far.
typedef int (*ptr)();
int HHH(ptr P);
void Infinite_Recursion()
{
Infinite_Recursion();
return;
}
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(Infinite_Recursion);
HHH(DD);
}
It is a verified fact that DD correctly simulated by HHH
cannot possibly reach its own simulated "return" statement
final halt state.
No, it is verified that HHH never correctly simulates ANY input it says
in non-halting, and thus your criteria iis just non-sense.
The actual Correct Simulation of Infinite_Recursion is non-halting, so
HHH can be correct about it.
But the actual Correct Simultion of DD, is to see it call HHH(DD) which
you have defined will return 0, and thus the correct simulation of DD
will halt.
Yes, it happens AFTER HHH aborted its simulation, but by aborting it
forfeted the ability to have its partial simulation be the correct
simulation of the input.
It is a verified fact that HHH(DD) correctly detects this.
No, it is a verified fact that you are just a liar.
To be talking about the Halting Problem both HHH and DD must be "programs"
That means they include ALL the code they use (so DD include the code of
that specific HHH) and that code must be fully defined and
deterministic, and thus HHH must always do the same thing.
Youyr "LOGIC", uses lies like HHH is several different machines, and
these different machine are given different input, so trying to equate
their behavior is just a lie.
THis has been pointed out to you many times, so your repeating that
error without trying to answer the problems shown, just demonstrates
that you are just comfortable with being an ignorant liar, and don't
care about what the words you use actually mean.
Of course, that also shows because you don't understand that the finite
string given to HHH is in a special language, and that the meaning of
that string is EXACTLY the description of the program DD, which defines
its behavior.
Your trying to change that meaning is EXACTLY the same error you do with
your proof, LIE about what the statement means.
The only way out is by analysis - by looking at the instructions and
figuring out what they do. And the moment HHH tries to do that, it
will find itself in a whole heap of head-scratching trouble (assuming
it manages the analysis ) because it will know that whatever it
replies will be a lie.
<snip>
It is a verified fact that DD correctly simulated by HHH
cannot possibly reach its own simulated "return" statement
final halt state.
Nope, some other non-existant in this problem by only existing in a hypothietcal alternate world, when simulating a DIFFERENT, and also non-existant in this problem string representing the hypothetical input
to that other problem show that OTHER not existing here input doesn't halt.
It is just a lie to call them the same.
It is a verified fact that HHH(DD) correctly detects this.
Nope, because you can't correctly determine as true a false statement.
This has been fully operational C/C++ for three years. https://github.com/plolcott/x86utm
Which actually proves that you are lying.
DD halts.
HHH(DD) says it doesn't.
UTM(DD) halts.
And thus HHH is just wrong, and you are shown to be just a stupid
ignorant pathological liar.
--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)