Re: DD correctly simulated by HH cannot possible halt --- Try to prove otherwise --- x86 DD

On 6/2/24 4:21 PM, olcott wrote:

On 6/2/2024 3:11 PM, Richard Damon wrote:

On 6/2/24 3:34 PM, olcott wrote:

On 6/2/2024 2:22 PM, Richard Damon wrote:

On 6/2/24 3:13 PM, olcott wrote:

On 6/2/2024 2:05 PM, Richard Damon wrote:

 

On 6/2/24 2:29 PM, olcott wrote:

On 6/2/2024 1:13 PM, Richard Damon wrote:

On 6/2/24 1:59 PM, olcott wrote:

On 6/2/2024 12:22 PM, Richard Damon wrote:

On 6/2/24 10:19 AM, olcott wrote:

>
Semantic tautologies are self-evident truth that prove themselves.
It is a fact that every five pound rock weights more than any
three pound rock. No need to weigh any rocks.

>
Right, so you don't need to weigh a five pound rock to know it is five bpounds.
>

>
typedef int (*ptr)();  // ptr is pointer to int function in C
00       int HH(ptr p, ptr i);
01       int DD(ptr p)
02       {
03         int Halt_Status = HH(p, p);
04         if (Halt_Status)
05           HERE: goto HERE;
06         return Halt_Status;
07       }
08
09       int main()
10       {
11         HH(DD,DD);
12         return 0;
13       }
>
Likewise we correctly deduce that for every HH/DD pair of the
infinite set of all HH/DD pairs that match the above template
every DD correctly simulated by HH never reaches past its own
simulated line 03, thus never halts.

>

>
When for every freaking HH/DD pair that matches the above template
DD correctly simulated by HH cannot possibly ever reaches past its
own simulated line 03 then
>
we know with complete logical certainty that not a damn one of
these DD instance halts. halts, NOT A DAMN ONE OF THEM EVER HALTS.

>
Nope, and you are just proving you are totally out of touch with reality.
>
EVERY DD built on an HH that returns 0 for HH(DD,DD) will Halt.
>

>
I am going to give up on you because you continue to try
to get away with the straw-mam deception CHANGE-THE-SUBJECT
fake rebuttal.

>
Nope. I am not "Changing the subject" but showing that your subject is incorrect or irrelevent.
>

>
This is the only post that I will reply to and unless you
either accept that DD correctly simulated by HH will never
halt for the infinite set of HH/DD pairs specified below
or correctly refute the paragraph relating to the x86 code
of DD shown below *I will simply not respond to your posts*

>
Which I won't do until you say why it matters.
>

>
(a) Accept the DD/HH that DD never halts
(b) Correctly refute the x86 DD
*EVERYTHING ELSE WILL GET NO RESPONSE FROM ME*

>
And thus a whole list of posts refuting everything that you say that you will just be forced to leave out there or convict yourself of LYING.
>

>
typedef int (*ptr)();  // ptr is pointer to int function in C
00       int HH(ptr p, ptr i);
01       int DD(ptr p)
02       {
03         int Halt_Status = HH(p, p);
04         if (Halt_Status)
05           HERE: goto HERE;
06         return Halt_Status;
07       }
08
09       int main()
10       {
11         HH(DD,DD);
12         return 0;
13       }
>
>
DD correctly emulated by HH with an x86 emulator cannot possibly
reach past its own machine instruction [00001c2e] in any finite
(or infinite) number of steps of correct emulation.

>
But any such finite simulation

>
DD correctly emulated by HH with an x86 emulator cannot possibly
reach past its own machine instruction [00001c2e] in any finite
(or infinite) number of steps of correct emulation.
>
(or infinite) number of steps of correct emulation.
(or infinite) number of steps of correct emulation.
(or infinite) number of steps of correct emulation.
(or infinite) number of steps of correct emulation.

>
But you only show the "or infinite number of steps" for DDs built on an HH that never aborts.
>

>
Maybe you are having a bad day. You are already forgetting how
you just chastised me last night for not equating finite number
of steps with an aborted simulation.

>
So, what is your confusion.
>
The only DDs that you have simulated for an infinte number of steps are those DDs built on an HH that NEVER ABORTS its simulation.
>

 Just like every rock that weighs more than five pounds weighs
more that three pounds
 When every DD correctly simulated by every HH that can possibly
exist DOESN'T HALT THEN NONE OF THEM HALT.
 

WRONG, and shows that you are a LIAR.
Every DD is NOT simulated by *EVERY* HH, but each HH only simulates ONE DD.
Thus, your arguement is just based on your pathological LIES that you always tell.
EVERY DD based on an HH that aborts its simulation of HH(DD,DD) and returns 0 will Halt.
EVERY HH that doesn not abort its simulation of HH(DD,DD) will not answer, as it gets stuck in an infinite simulation loop.
Thus *NO* HH correctly answers about its DD halting.
And you have just shown that you have WASTED your last 20 years by brainwashing yourself into believing your lies and not bothering to actual learn anything about the topic you talk about.
You are nothing but a DAMNED ingnorant pathological lying idiot, that has a reckless disregard for what is true, but who belives his own lies despite the evidence that you just refuse to look at.
You are worse than the election deniers that you claim you want to educate to have them see the truth.
You just show why that is such a tough job, because you BLINDELY believe what you want, and ignore all the evidence, because you have lost contract with reality.