Re: Flat out dishonest or totally ignorant?

On 7/1/24 11:31 PM, olcott wrote:

On 7/1/2024 10:09 PM, Richard Damon wrote:

On 7/1/24 10:52 PM, olcott wrote:

On 7/1/2024 9:35 PM, Richard Damon wrote:

On 7/1/24 10:09 PM, olcott wrote:

On 7/1/2024 8:51 PM, Richard Damon wrote:

On 7/1/24 9:25 PM, olcott wrote:

typedef void (*ptr)();
int HHH(ptr P);
>
void Infinite_Loop()
{
   HERE: goto HERE;
}
>
void Infinite_Recursion()
{
   Infinite_Recursion();
}
>
void DDD()
{
   HHH(DDD);
}
>
int main()
{
   HHH(Infinite_Loop);
   HHH(Infinite_Recursion);
   HHH(DDD);
}
>
Every C programmer that knows what an x86 emulator is knows
that when HHH emulates the machine language of Infinite_Loop,
Infinite_Recursion, and DDD that it must abort these emulations
so that itself can terminate normally.

>
Right.
>

>
Then why do you contradict yourself below? Did you forget to lie?

>
Because I didn't contradict my self or lie, as the programs are different.
>

>
See what you agreed to by re-reading the words that
you agreed to and you will see that you forgot to lie
this time.
>

>
Your streaching. You know what I mean, and if you want to get finicky, I will pull out the doxens of LIES that you have implicitly admitted to by not providing the references you claimed to have.
>
Yes, HHH must abort its emulation to return, but that doesn't mean that THIS input in non-halting.

 *I tricked you into forgetting to lie so you told the truth*

No, your tricked your self into admitting your logic needs to use trickery, and fell into your own trap.
Yes, you need to choose an HHH that aborts the DDD that is made from it to have an HHH that returns, but this does not meen that htis HHH NEEDS to abort its emulation of its input, but does. The difference is that for the first question, we still have free reign to choose the decider, and the input hasn't been actually created, just the template for the input (since to have behavior, it needs to be a specific program).
The second quesition, the decider and the input have been fixed, so when we hypothosize about need, and look at an alternate decider, the input, having been fixed, doesn't change. Thus, the full simulation that "needs to" refers to sees the decider emulate the input, and INCORRECT decide to abort and return to its caller which hahalts, thus showing no NEED to abort in the decider.

 <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
     specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>

But here "Correct Simulation" means a simulation that exactly reproduces the behavior of directly running the program represented by the input, which means on the NEVER aborts its simulation.
Since your H does neither that type of simulation, nor correctly predict what that type of simulation would do, you can't correctly use the second paragraph.
Then you have that you input doesn't actually represent a full program, so you just start with an error, but one we can correct since we know the decider that you intend to pair it with.

 As Ben has already agreed to criteria has been met.

Nope, again, putting false words into other mouths.

>
I could point out that it is IMPOSSIBLE for you HHH to actually correctly do the emulation you claim on the input provided (since there is no code provded to emulate the call HHH) so your question is just invalid.

 *You already know that I already provided this code*
https://liarparadox.org/HHH(DDD)_Full_Trace.pdf
 

Which isn't the trace described, and Isn't even the full code as there ard empty stubs that seem to be replaced.
So, you just continue ti LIE.