On 6/2/2024 9:24 PM, Richard Damon wrote:
On 6/2/24 9:45 PM, olcott wrote:
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.
Which means NOTHING, as your definition of "correctly Simulated" doesn't meet the requirements to talk about the behavior of the machine described by the input.
IT HAS ALWAYS BEEN ABOUT THE BEHAVIOR THAT THE IN[UT SPECIFIES.
That you did get confused by the Linz text proves that you do
get confused. Previously it looked just like willful deception.
You don't seem to understand that you can't just "redefine" the system to meet your desires.
Deciders compute the mapping FROM THEIR INPUTS.
DD correctly simulated by HH specifies NON-HALTING.
Deciders compute the mapping FROM THEIR INPUTS.
DD correctly simulated by HH specifies NON-HALTING.
Deciders compute the mapping FROM THEIR INPUTS.
DD correctly simulated by HH specifies NON-HALTING.
You can't get away with implicitly saying that you
just don't "believe in" UTMs.
You can't get away with implicitly saying that you
just don't "believe in" UTMs.
You can't get away with implicitly saying that you
just don't "believe in" UTMs.
That is why all you are actually talking about is POOP.
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.
Then it just isn't a Halt Decider. PERIOD, and your whole arguement fails, and is based on just lying.
Deciders compute the mapping FROM THEIR INPUTS.
DD correctly simulated by HH specifies NON-HALTING.
You can't get away with implicitly saying that you
just don't "believe in" UTMs.
As I have pointed out, by your definitions, a triial decider can just declare that virtual all input are non-halting and be "just as correct", since the logic you try to use is just invalid.
>
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*
>
D(D) is the counter example.
Liar Liar Pants ON Fire
*We can see that the following DD cannot possibly halt when*
*correctly simulated by every HH that can possibly exist*
*We can see that the following DD cannot possibly halt when*
*correctly simulated by every HH that can possibly exist*
*We can see that the following DD cannot possibly halt when*
*correctly simulated by every HH that can possibly exist*
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; Geniushits a target no one else can see." Arthur Schopenhauer
D correctly simulated by H cannot possibly halt --- templates and infinite sets
Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets