Re: HHH maps its input to the behavior specified by it --- never reaches its halt state

On 8/8/24 9:18 AM, olcott wrote:

On 8/8/2024 3:13 AM, Mikko wrote:

On 2024-08-08 04:41:11 +0000, olcott said:
>

On 8/7/2024 8:22 PM, Richard Damon wrote:

On 8/7/24 9:12 PM, olcott wrote:

On 8/7/2024 8:03 PM, Richard Damon wrote:

On 8/7/24 2:14 PM, olcott wrote:

On 8/7/2024 1:02 PM, joes wrote:

Am Wed, 07 Aug 2024 08:54:41 -0500 schrieb olcott:

On 8/7/2024 2:29 AM, Mikko wrote:

On 2024-08-05 13:49:44 +0000, olcott said:

>

I know what it means. But the inflected form "emulated" does not mean
what you apparently think it means. You seem to think that "DDD
emulated by HHH" means whatever HHH thinks DDD means but it does not.
DDD means what it means whether HHH emulates it or not.
>

In other words when DDD is defined to have a pathological relationship
to HHH we can just close our eyes and ignore it and pretend that it
doesn't exist?

It doesn't change anything about DDD. HHH was supposed to decide anything
and can't fulfill that promise. That doesn't mean that DDD is somehow
faulty, it's just a counterexample.
>

>
void DDD()
{
   HHH(DDD);
   return;
}
>
*HHH is required to report on the behavior of DDD*
Anyone that does not understand that HHH meets this criteria
has insufficient understanding.

>
But it doesn't, as a correct simulation of a DDD that calls an HHH that returns will stop running,

>
I really think that you must be a liar here because
you have known this for years:
>
On 8/2/2024 11:32 PM, Jeff Barnett wrote:
 > ...In some formulations, there are specific states
 >    defined as "halting states" and the machine only
 >    halts if either the start state is a halt state...
>
 > ...these and many other definitions all have
 >    equivalent computing prowess...
>
Anyone that knows C knows that DDD correctly simulated
by any HHH cannot possibly reach its "return" {halt state}.
>

>
But the problem is that you HHH ODESN'T correctly emulate the DDD it is given, because it aborts its emulation.
>

>

>
Every one can see that Olcott is trying to get way
with ad-hominem instead of staying on topic.
>

 void DDD()
{
   HHH(DDD);
   return;
}
 Each HHH of every HHH that can possibly exist definitely
*emulates zero to infinity instructions correctly* In
none of these cases does the emulated DDD ever reach
its "return" instruction halt state.

Nope, see below.

 *There are no double-talk weasel words around this*
*There are no double-talk weasel words around this*
*There are no double-talk weasel words around this*

You sure use a lot of them

 There is no need to show any execution trace at the x86 level
every expert in the C language sees that the emulated DDD
cannot possibly reaches its "return" instruction halt state.

Nope. See below for the proof.
Note, if you can't show the trace, you can't make the claim that it did it that way.
You just don't understand what you are talking about.

 Every rebuttal that anyone can possibly make is necessarily
erroneous because the first paragraph is a tautology.
 

Nope, it is a lie based on comfusing the behavior of DDD which is what "Halting" is.
Remember, the definition of "Halting" is THE PROGRAM reaching a final state. I will repeat that, it is THE PROGRAM reachibg a final state.
A Program, it the COMPLETE collection of ALL the instructions possible used in the execution of it, and thus, the PROGRAM DDD, includes the instructions of HHH as part of it, so when you pair different HHHs to the C function DDD, to get programs, each pairing is a DIFFERENT input.
Also, to be a valid input to decide on, it must contain all the information needed, and thus your version with just the bytes of the C function is NOT a valid input to decide on, and any claim based on that would just be a lie.
Now, when we look at your claimed about DDD correctly emulated for only a finite number of steps, and remembering that Halting is based on the behavior of the FULL program, the partial emulation does NOT define the behavior of that DDD. We CAN look at a Complete and Correct Emulation, which would be given the exact same input to the version of HHH that never aborts, and since the pairing of DDD to HHH creates a different DDD for each input, that means that we don't have this non-aborting HHH look at the DDD that calls the n\on-aborting HHH, but the DDD that calls the HHH that did abort after the finite number of steps. (And if you can't build that test, you are just proving your system is not Turing Complete, and thus not suitable for trying to use for the halting problem.
This emulation, will, BY DEFINITION, see exactly what the dirrect execution of DDD does (or even your non-aborting HHH doesn't correctly emulate its input), will see DDD call HHH, then, by your definition, that HHH doing some emulation, and then after that finite number of steps emulated, will abort its emulation and return to DDD and that DDD will reach its final state and be halting
THus, we have just proved that for every HHH that emulates from 0 to a arbitrary large finite number of steps of DDD correctly, and then return 0, while its emulation doesn't reach the final return instruction, the COMPLETE CORRECT emulation of the same input does, as does the direct execution of the machine that the input represents.
Thus, your claimed "tautology" is a incorrect statement for all but one case, that of an HHH that emulates an INFINITE number of steps correctly, but that HHH can never answer about the behavior of its input, so is not a correct halt decider either.