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

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.

 DD correctly emulated by HH with an x86 emulator cannot possibly
reach past its own machine instruction [00001c2e]
 in any finite
in any finite
in any finite
in any finite
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.

AND WHO CARES ABOUT NOT BEING ABLED TO BE SIMULATED PAST THE CALL INSTRUCTION
**YOU** are the one changing the subject, as before you were talking about DD not halting, NOT it not to be able to be simulated by HH past the call instruction.

 

EVERY version of DD is a different input.
>

 Just the same way that every rock that weighs more than five pounds is
a different rock, YET THEY ALL WEIGH MORE THAN FIVE POUNDS.

Yep. Because that IS a property of them.
But the simulation of one DD doesn't tell you anything about the simulation of another.
That is like saying that since one 5 pound rock was pink, all of them are.
Halting is NOT the same property as not being able to be simulated by HH past a certain point. So you seem to have rocks in your head.

 

And every version of DD built on an HH that does abort and returns 0 will Halt.
>

 I am not using that screwy language it seems dishonest of you
to paraphrase my words that way.

So, do you disagree that every HH that simulates its DD for only a finite number of steps doesn't abort?

 Every DD correctly simulated by DD DOES NOT HALT. I really want
to move on to the much bigger issue of why the behavior of the
directly executed DD(DD) DOES NOT MATTER.

WRONG. (I presume you mean HH)
If the HH simulates for only a finite number of steps, and then aborts its simulation, then the DD built from that HH, the DD(DD) will halt.
The only other case is the HH that does simulate an infinite number of steps, and those HH never answer.
Note, this is again you switching the topoc back to not-halting instead of your diversion to not-simulated-by-HH-past-the-call-instruction.
These are DIFFERENT properties, and you try to LIE by assuming they are the same.

 We certainly can't move on to bigger issues when you prove
that you cannot handle the trivial ones.

So, which of the two cases are you talking about.
The ones where HH answers, and you LIE that the DD built on them does not halt, as it does.
or, are the only HHs in existance ones that NEVER abort there simulation, and thus never answer?
ONE HH can not be a bit of both.

 

it seems you have forgotten the details of what a program is, and I guess you logic insists that a cat is the same as a 10 story office building since different things can be the same thing.
>

>

doesn't prove that the machie being simulated is non-halting.
>
All you are proving is that the DDs that are provable to be non-halting are built to refute HHs that never answer about them.
>

>
_DD()
[00001c22] 55         push ebp
[00001c23] 8bec       mov ebp,esp
[00001c25] 51         push ecx
[00001c26] 8b4508     mov eax,[ebp+08]
[00001c29] 50         push eax        ; push DD 1c22
[00001c2a] 8b4d08     mov ecx,[ebp+08]
[00001c2d] 51         push ecx        ; push DD 1c22
[00001c2e] e80ff7ffff call 00001342   ; call HH
[00001c33] 83c408     add esp,+08
[00001c36] 8945fc     mov [ebp-04],eax
[00001c39] 837dfc00   cmp dword [ebp-04],+00
[00001c3d] 7402       jz 00001c41
[00001c3f] ebfe       jmp 00001c3f
[00001c41] 8b45fc     mov eax,[ebp-04]
[00001c44] 8be5       mov esp,ebp
[00001c46] 5d         pop ebp
[00001c47] c3         ret
Size in bytes:(0038) [00001c47]
>
>
>

>

>

>