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

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

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

On 6/2/2024 5:20 PM, Richard Damon wrote:

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

On 6/2/2024 4:43 PM, Richard Damon wrote:

On 6/2/24 5:25 PM, olcott wrote:

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

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

*We can see that the following DD cannot possibly halt*

>
Unless the HH(DD,DD) aborts its simulation and returns 0, then DD(DD) will ALWAYS halt when directly called, which is the definition of "Halting".
>
Not your LIE that it pertains to partial simulations.
>

*when correctly simulated by every HH that can possibly exist*

>
Except for EVERY HH that aborts its simulation and returns 0
>

>
This may be an ADD thing.
For every HH that aborts its simulation and returns 0
DD correctly simulated by this HH *DID NOT HALT AND NEVER WILL HALT*

>
Except you mental problems are getting in YOUR way.
>
You said that "DD Can not halt" NOT "the simulation by H of DD can not Halt"
>

>
*I said neither of those things so it may be an ADD problem*

>
I guess your medication is making you blind.
>
Read the top line quoted from you on 6/2/24 4:50 PM
>
You said:
    "*We can see that the following DD cannot possibly halt*"
>

>
*Deceitfully taking things out of context*
>
On 6/2/2024 3:50 PM, olcott wrote:
 > *We can see that the following DD cannot possibly halt*
 > *when correctly simulated by every HH that can possibly exist*

 But the second line doesn't change the meaning of the first line, as Halting ALWAYS (unless clearly modified) refers to the behavior of the machine.
 

I was wrong to call you deceitful on this, I sincerely apologize.
The above two lines are the same single sentence that I wanted
to make bold. Putting a period at the end or not breaking it up
into two lines makes bold not work.

It just qualifies which DD we might be talking about.
 Just like the sentence:
 

My whole point has ALWAYS been DD correctly simulated by HH.
DD specifies non-halting behavior to the simulator/UTM aspect
of DD. DD(DD) has different behavior that decider HH is not
actually held accountable for. HH is ONLY held accountable
for the behavior that DD specifies to its simulator/UTM aspect.

We can see that the house was red when the ball went through the window.
 The ball going through the window doesn't affect the color attribute of the house. It might qualify the WHEN (but Halting of a machine isn't dependent on time) or which house we are talking about (so it clearly makes it a DD that it paired to an HH), but it doesn't affect the color.
 Just like the fact that you have given the description of this DD to HH, doesn't affect the behavior of that instance of DD, it only might indicate that it HAS been paired with such an HH and not some other thing.
 

>

Remember, Halting is defined as the MACHINE reaching a fianl state, so trying to qualify it with a partial simulation is an irrelevent qualification.
>
>

>

Those are DIFFERENT statements.
>
DD WILL Halt.
>
Your claim, that I will neither confirm or deny (until you can show why I should), is that the simulation by H can never reach the statement after the call instruction.
>

>
*Still not quite what I said*

>
But you did in your message from 3:54 today earier in the thread:
>
   DD correctly emulated by HH with an x86 emulator cannot possibly
   reach past its own machine instruction [00001c2e]
>

>
If you get my words 99.99999% perfectly then you screwed up
far too much, thus 80% is not in the ballpark.

 So, if you ever slightm
 

>
*We can see that the following DD cannot possibly halt*
*when correctly simulated by every HH that can possibly exist*

 Nope ABSOLUTE LIE.
 

*If it was even incorrect then you could show a counter-example*
That it is categorically impossible to show a counter-example
conclusively proves that it is correct. I really hope that you are
merely confused about this. I really hope you are not risking your
salvation.

Hlating is a property of the MACHINE  /  PROGRAM, not the simulation.
 DD(DD) WILL HALT as long as HH(DD,DD) returns 0, and any HH(DD,DD) that doesn't return 0 fails to meet your requirement that HH be a decider, so we can automatically filter those out.
 

My whole point has ALWAYS been DD correctly simulated by HH.
DD specifies non-halting behavior to the simulator/UTM aspect
of DD. DD(DD) has different behavior that decider HH is not
actually held accountable for. HH is ONLY held accountable
for the behavior that DD specifies to its simulator/UTM aspect.

You not understanding what your words mean is YOUR problem.
 And you are just proving that you have a reckless disregard for the truth, showing that you are just an ignorant pathologial liar.
 

I really hope that you are  merely confused about this.
I really hope you are not risking your salvation.

You MIGHT be able to claim that the SIMULATION of DD when correctly performed by HH can never reach a final state. That is the claim you seem to be working on, which i will neither confirm nor deny until we handle this issue.,
 

*DD simulated by HH cannot possibly halt*
Saying the opposite way makes it looks like HH is not a good
enough simulator. HH is a perfectly correct simulator of its N
steps of correct simulation. After N steps of correct simulation
HH correctly recognizes that DD cannot possibly halt no matter
how many steps are simulated.

Your statement about HALTING is just incorrect.
 

Not at all. It has always been correct and you have denied the
verified facts. If this is through confusion then there is no
risk to your salvation. I really hope it is because of confusion.
I don't want you to lose your salvation.

Try to PROVE your statement
 Quote ACTULAL Definitions and accepted scholarly publish works in the field.
 So far, it is just "Olcott says" and Olcott has been proven to LIE and is often mistaken, so not a reliable source.
 

For the last few months I HAVE ONLY BEEN TALKING ABOUT
SOFTWARE ENGINEERING AND YOU HAVE CONSISTENTLY DENIED
THE VERIFIED SOFTWARE ENGINEERING FACTS.
There is no HH that can possibly exist such that DD correctly
simulated by HH can possibly reach past its own line 03.

>
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       }
>
_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]
>

 

--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer