Re: What it would take...

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

On 5/10/2025 11:18 AM, wij wrote:

On Sat, 2025-05-10 at 10:46 -0500, olcott wrote:

On 5/10/2025 10:35 AM, wij wrote:

On Sat, 2025-05-10 at 10:07 -0500, olcott wrote:

On 5/9/2025 9:18 PM, Richard Damon wrote:

On 5/9/25 9:11 PM, Richard Heathfield wrote:

The HHH code doesn't exactly invite confidence in its author, and his
theory is all over the place, but a thought experiment suggests itself.
>
If we were not all wasting our time bickering with a career
bickerer... if we were to really /really/ try, could we patch up his
case and send him on to his Turing Award? And if so, how?
>
ISTR that there is suspected to be a theoretical window for him, so I
suppose what I'm asking is what sort of boathook we would need to poke
that window a little wider.
>
Can he even get there from here? Evidence would suggest that
simulation is a dead end unless he can find a way to get the simulated
program to include its own simulation in its behaviour, which he has
not yet managed to do - but /is/ there a way?
>
Or could he abandon simulation completely and instead write a TM
parser that builds an AST and walks it looking for evidence of
terminating or looping? If he could, would that turn the trick?
>
Or do we have a latter day Cantor waiting in the wings to close the
window once and for all?
>
Is there, in short, any way of putting out this un-halting flame war
and turning this group to better use?
>

>
If he was willing to include the code for HHH in the input representing
DDD, then HHH would be able to atempt to correctly emulate this input.
>

>
DDD and HHH have always been in the same memory space.
DDD is the program under test and HHH is the test program.
>

There have been methods put forward, that given an acceptace of the
detectability of DDD calling HHH, which can only be done it seems if we
make the system non-turing complete by saying that the input program and
the decider are put into the same memory space, and we are not allowed
to "copy" an algorithm to make a new copy, but only call the origianal
version so HHH can detect the recursion by reference to that address
that some versions of programs that do this "recursive simulation" can
be correctly decider (but not all, like the pathological version).
>

>
HHH is essentially a UTM thus EVERYTHING is in the memory space
of its UTM tape.
>

In this method, the Decider detecting the recursion, tries emulating the
code in two parrallel branches based on both possible answers, and if
one branch matches the behavior of the answer, it can return that answ3er.
>

>
We can emulate a branch as if a conditional expression
was true and as if it was false. HHH determines the
behavior of DDD on the basis of what would happen if
HHH never aborted.
>
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
       If simulating halt decider H correctly simulates its
       input D until H correctly determines that its simulated D
       *would never stop running unless aborted* then
>

Thus, inputs like DDD() that always halt on the return of HHH(DDD) will
be correctly determined to be halting, and a varient that just goes into
an infinite loop can be such detected by well know procedures as non-
halting.
>

>
When HHH continues to emulate DDD until HHH sees the
repeating pattern that would prevent DDD from ever
terminating
>
       H can abort its simulation of D and correctly report that D
       specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
>

The pathological DD() is detected as pathological, and we can perhaps
extend the definition to allow it to respiond with an "I give up, I
don't know the answer" response, but such an extention explicitly does
NOT meet the requirements, but is better than not answering or giving a
wrong answer.
>
The problem is this result doesn't meet Peter's Goal, as it isn't really
the Halting Problem that he has his major problem with, but the fact
that Turings Proof became the basis for a number of broader proofs of
incompleteness and undeciability that fills formal logic.
>
This is what he can't handle, and this is because he just doesn't really
understand how all of the works because his mental models of logic is
just way to small and simple.

>
Dodge and weave is all you know.
>
int DD()
{
     int Halt_Status = HHH(DD);
     if (Halt_Status)
       HERE: goto HERE;
     return Halt_Status;
}
>
It is a verified fact that DD correctly emulated
by any simulating termination analyzer HHH specifies
a non-terminating sequence of configurations.
>

>
Nope.
POOH is intended to decide whether the input D is "impossible" input or not.
>

>
counter-factual.

>
Why? I made the conclusion from your reply. If what I concluded is 'counter-factual',
then your previous replies are counter-factual.
Do you deny what you had said?
>

 For HHH(DD) DD is easy thus not impossible.
 

Really? Where is the error in my analysis?
How does HHH emulate code that is isn't allowed to look at?
Or, ar you just admitting you are so stupid you don't understand those basic rules.