Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD)

On 5/10/25 6:03 PM, olcott wrote:

On 5/10/2025 4:44 PM, wij wrote:

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

On 5/10/2025 2:02 PM, wij wrote:

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

On 5/10/2025 1:37 PM, wij wrote:

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

On 5/10/2025 1:09 PM, wij wrote:

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

On 5/10/2025 12:01 PM, wij wrote:

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

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

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

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

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

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

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

On 5/10/2025 7:37 AM, Bonita Montero wrote:

Am 09.05.2025 um 04:22 schrieb olcott:
>

Look at their replies to this post.
Not a one of them will agree that
>
void DDD()
{
           HHH(DDD);
           return; // final halt state
}
>
When 1 or more instructions of DDD are correctly
simulated by HHH then the correctly simulated DDD cannot
possibly reach its "return" instruction (final halt state).
>
They have consistently disagreed with this
simple point for three years.

>
I guess that not even a professor of theoretical computer
science would spend years working on so few lines of code.
>

>
I created a whole x86utm operating system.
It correctly determines that the halting problem's
otherwise "impossible" input is actually non halting.
>
int DD()
{
           int Halt_Status = HHH(DD);
           if (Halt_Status)
             HERE: goto HERE;
           return Halt_Status;
}
>
https://github.com/plolcott/x86utm
>

>
Nope.
        From I know HHH(DD) decides whether the input DD is "impossible"
input
or
not.
>

>
DD has the standard form of the "impossible" input.
HHH merely rejects it as non-halting.
>

>
You said 'merely' rejects it as non-halting.
So, POOH do not answer the input of any other function?
>

>
The input that has baffled computer scientists for 90
years is merely correctly determined to be non-halting
when the behavior of this input is measured by HHH
emulating this input according to the rules of the x86
language.
>
The same thing applies to the Linz proof yet cannot
be understood until after HHH(DDD) and HHH(DD) are
fully understood.
>

>
HHH(DDD) (whatever) at most says DDD is a pathological/ midtaken input.
Others of what you say are your imagine and wishes, so far so true.
>

>
DDD emulated by HHH accor not the 'HHH' that makes the final decision

(otherwise, it will be an infinite recursive call which you agreed)
>

ding to the rules of
the x86 language specifies recursive emulation
that cannot possibly reach the final halt state
of DDD.
>

>
I have no problem with that. And, you said HHH merely rejects it as non-halting.
You had denied HHH can decide the halting property of any input, except DDD/DD/D..
>

>
As long as HHH correctly determines the halt status
of a single input that has no inputs then HHH is
a correct termination analyzer for that input.

>
Go it, that is a stronger statement that HHH ONLY decides DD.
I have no problem with that, but be noticed that the HHH inside DD
is not the 'HHH' that makes the final decision (otherwise, the 'HHH'
will be an infinite recursive which cannot make any decision, which
you had agreed)
>

>
HHH(DD) correctly determines that its input specifies
recursive emulation when this input is emulated by HHH
HHH according to the rules of the x86 language.

>
   From the about, so you are talking about 'the HHH' which does not compute the final
decision.
>

>
HHH does recognize the recursive emulation pattern
of DDD emulated by HHH according to the rules of
the x86 language.
>

*Thus exactly meets the following specification*
<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
>
        H can abort its simulation of D and correctly report that D

>
This H won't be the same HHH inside the DD, otherwise an infinite recursive call happens.
>

>
It must always be the outermost HHH that does this
because it has seen one entire recursive emulation
more than the next inner HHH.

>
No problem. H is not HHH.
>

>
The H is the template that Professor Sipser agreed to.
HHH is a specific implementation of H.
>

This is also a pitty no one here understand POOH can help AI industry and mankind, even so mini.
>

>
It is the same halting problem after its mistake
has been corrected. So just like how ZFC corrected
the error in set theory so that Russell's Paradox
could be correctly decided, HHH corrects the error
in the halting problem proof so that the otherwise
impossible input is correctly decided.

>
I don't know what that part of set theory works.
(My feeling is that they are garbage, for reasons,
unless you are doing logic researches)
>

The original set theory is now called naive set
theory after its mistake has been corrected. Thus
the original halting problem proofs can now be
called the naive halting problem proofs.

>
Traditional logic (or the part mostly used) that won't
cause confusion is more reliable.
>

The halting problem itself remains the same, yet
loses its most important proof.

>
HP is based on TM. Proof of any other kind other than TM have to be cautious.

 Unless this is done as an actual simulating termination
analyzer in a high level language like C and it operates
on a 100% complete exactingly precise input specification
such as the x86 language too many details slip through
the cracks of vagueness.

Nope. You need to use the vagueness of High level languages and complex machines to hide your compuational shenanigans.

 For example no one ever even noticed that it is 100%
impossible to derive an input that actually does the
opposite of whatever value that its termination
analyzer reports.

Sure they have. Your problem is you don't understand what the meaning of correct or behavior is.

All of these proofs remain anchored in that false
assumption.

No, all your preofs are anchored in false assumptions, like that 1 step correctly emulated is a correctly emulated program.
I guess you think answer 1 question on the IQ test coffectly and then stopping means you got the test correct, even though you never answered the other 99.
"Correct Emuation" means correctly emulating *ALL* the steps, and 1 to n steps was not all.

 

The part of 'logic' or 'philosophy' I saw from your posts are very dubious,
hardly valid for HP.
>
I think you are referring to (and confused by) self-reference.
Sadly, the HP proof has nothing to do with self-reference.
Let me make the counter example this way:
>
void D() {
   for(int X; X<LimX; ++X) {   // X would enum all possible 'TM' whose value<LimX
     if(simu(H',X) while(1);   // H' decides whether X halts or not
   }                           // (If X is not a valid program, simu(H',X) returns 0.
                               //  So, this H' is not exactly the halting decider H
                               //  but can be build from the original H)
}
>
So, there exists an encoding X that functions the same as D that H cannot decide.
(note that no function call or self-reference in the above D)
>
The above D can be simplified to form another "impossible input":
>
void D2() {
   if(simu(H',D2') while(1);   // D2' is the 'source' of D2, also no self ref. RECURSIVELY.
}
>

 I have no idea what you are saying.
 

Yep, that is your problem.

        specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
>
Professor Sipser is the best selling author of theory of
computation textbooks.
It is a pity that he could never take the five more minutes
required to understand the notion of recursive emulation and
thus see the significance of my work.

>
You can cite any one, I don't know who Sipsper is.
But yes, it is also a pity that Socrites and Turing did not know POOH.
>

>
https://www.amazon.com/Introduction-Theory-Computation-Michael- Sipser/dp/113318779X
>

>
>

>
>

>
>