On 7/20/25 12:06 PM, olcott wrote:
On 7/20/2025 10:47 AM, joes wrote:
Am Sun, 20 Jul 2025 09:30:08 -0500 schrieb olcott:
On 7/20/2025 6:13 AM, Richard Damon wrote:
When you add to the input the actual definition of "Non-Halting", as
being that the exectuion of the program or its complete simulation will >>>> NEVER halt, even if carried out to an unbounded number of steps, they
will give a different answer.
This is a whole other issue that I have addressed.
They figured out on their own that if DDD was correctly simulated by HHH >>> for an infinite number of steps that DDD would never stop running.
That is incorrect. The HHH called by DDD will hit the abort. (Of course
HHH can't simulate that since it aborts before instead of doing an
unlimited simulation.)
typedef void (*ptr)();
int HHH(ptr P);
void DDD()
{
HHH(DDD);
return;
}
int main()
{
HHH(DDD);
}
The HHH called by DDD simulated by HHH
cannot possibly reach its own abort.
Right, but the question isn't simulated by HHH, but simulated by an
unbounded simulation.
THis doesn't change what the input calls, whcih calls the HHH that
aborts and returns 0 and then halts.
Thus HHH was wrong, and you are proved to be just a liar.
<ChatGPT>
Misrepresentation of Input:
The standard proof assumes a decider
H(M,x) that determines whether machine
M halts on input x.
But this formulation is flawed, because:
Turing machines can only process finite
encodings (e.g. ⟨M⟩), not executable entities
like M.
So the valid formulation must be
H(⟨M⟩,x), where ⟨M⟩ is a string.
</ChatGPT>
The DDD() directly executed in main is not
in the domain of HHH.
And that notation is YOURS, the actual notation for H was:
H <M> w goes to qy if M w will halt and to qn if M w will not halt.
Note, it HAS the convert to a string notation.
Your provlem is you converted to an incorrect representation that
confuses the two.
Part of your problem is that HHH takes the wrong sort of thing as its
input, YOU made it take the address of the program, but your initial description was that it was to begin an object file with the code of the program. But you forgot about that because that likely broke your lies.
It truth, a PROPER decider should be given something more like an array
of bytes that represents the program consisting of the lenght of the
program, the address it is intended to be loaded into, and then the
bytes of the code.
The simulator when simulating that input would then access the code of
the program using a mapping between the "virtual" address inside the simulation, and the data in the input.
This would allow you to build an input that actually matches the proof,
that would actually include the copy of the decider, as it MUST to be
accessed, and could actually create the needed "copy" of its input.
--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)