Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down

On 6/1/2024 5:30 PM, Richard Damon wrote:

On 6/1/24 5:24 PM, olcott wrote:

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

On 6/1/24 4:37 PM, olcott wrote:

On 6/1/2024 3:29 PM, Richard Damon wrote:

On 6/1/24 3:51 PM, olcott wrote:

On 6/1/2024 1:54 PM, Fred. Zwarts wrote:

Op 01.jun.2024 om 20:07 schreef olcott:

On 6/1/2024 12:56 PM, Richard Damon wrote:

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

On 6/1/2024 12:33 PM, Richard Damon wrote:

On 6/1/24 1:27 PM, olcott wrote:

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

On 6/1/24 12:38 PM, olcott wrote:

On 6/1/2024 11:27 AM, Richard Damon wrote:

On 6/1/24 12:13 PM, olcott wrote:

On 6/1/2024 10:56 AM, Richard Damon wrote:

On 6/1/24 11:30 AM, olcott wrote:

>
*I will not discuss any other points with you until after you either*
(a) Acknowledge that DD correctly simulated by HH and ⟨Ĥ⟩ ⟨Ĥ⟩ correctly
     simulated by embedded_H remain stuck in recursive simulation for
     1 to ∞ of correct simulation or
>
(b) Correctly prove otherwise.

>
And until you answer the question of what that actually means, I will reply WHO CARES.
>

>
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       }
>
Every DD correctly simulated by any HH of the infinite set of HH/DD
pairs that match the above template never reaches past its own simulated
line 03 in 1 to ∞ steps of correct simulation of DD by HH.
>
In this case HH is either a pure simulator that never halts or
HH is a pure function that stops simulating after some finite number
of simulated lines. The line count is stored in a local variable.
The pure function HH always returns the meaningless value of 56
after it stops simulating.
>

>
So, still no answer, to teh question.

>
You can pretend that you don't understand something that you do indeed
understand into perpetuity.
>
The key measure of dishonestly would be that you continue to say
that you don't understand yet never ever point out exactly what you
don't understand and why you don't understand it.
>

I giuess that Mean YOU don't even know what you are asking, though it seems that now you are admitting that your HH doesn't actually ANSWER the question, so it isn't ACTUALL a decider for any function except the "56" mapping.
>
I will repeat the question and until you answer the question of what that actually means, I will reply WHO CARES.
>
DO you mean the simulation of the TEMPLATE DD,

>
*Of course I don't mean that nonsense. I mean exactly what I specified*
>

which means that we CAN'T simulate the call HH as we have no code past point to simulate, and thus your claim is just a LIE.
>
Or, do you mean a given instance of HH simulating a given instance of DD, at which point we never have the 1 to infinte number of simulatons of THAT INPUT, so your claim is just a LIE.
>

>
Every element of the infinite set of every H/D pairs...
Every element of the infinite set of every H/D pairs...
Every element of the infinite set of every H/D pairs...
>
*Its not that hard when one refrains from dishonesty*
We can't even say that you forgot these details from one reply
to the next because the details are still in this same post.
>

>
And every one gives a meaningless answer,

>
*THEN TRY TO REFUTE THIS UNEQUIVOCAL STATEMENT*
DD correctly emulated by HH with an x86 emulator cannot possibly
reach past its own machine instruction [00001c2e] in any finite
number of steps of correct emulation.
>

>
Why? I don't care about it.
>
As I have said, the implication of your definition of "Correct SImulation" means that this says NOTHING about the halting behavior of DD. (only not halted yet)
>

>
*THEN TRY TO REFUTE THIS UNEQUIVOCAL STATEMENT*
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.
>
When I say it that way you claim to be confused and what I do
not say it that way you claim what I say is incomplete proof.

>
WHy do I care? I won't spend the effort to even try to refute something that is clearly meaningless.
>
You seem to have a conflict of definitions, as a given DD will only ever be simulated by ONE given HH that only simuates for one number of steps.
>

>
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       }
>
You continue to either fail to understand or seemingly more likely
simply lie about the fact that every DD correctly simulated by any
HH that can possibly exist cannot possibly reach past its own line 03.

>
Only if the simulation of HH simulated by HH does not reach HH's return, otherwise the simulation of DD would go to line 04.
>

>
*THIS MEANS THAT THE INPUT TO HH(DD,DD) DOES NOT HALT*
*THIS MEANS THAT THE INPUT TO HH(DD,DD) DOES NOT HALT*
*THIS MEANS THAT THE INPUT TO HH(DD,DD) DOES NOT HALT*
>

>
If true: The input to HH is both DD and HH called by DD, so both DD and HH do not halt, but keep starting new instances of each other.
However, HH is required to halt, but it doesn't. So, the HH that halts is phantasy.

>
I have fully operational code that proves otherwise.
Any expert in the C programming language knows the
same thing from the C source-code.
>

>
>
And have yo tried it to see what your HH says about HH?
>
After all, just running H isn't good enough by your rules, as you reject the fact that DD(DD) Halts just because it does when main calls it.
>

>
*We have been going over this same point for 2.5 years*
>
Pages 4-5 of
*The 2021-09-26 version of my first paper on simulating halt deciders*
*Halting problem undecidability and infinitely nested simulation*
https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation

>
Which is supposed to show WHAT?
>
you have shown main() calling D(D) once to my memory, and that shows that D(D) Halts.
>

>
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       }
>
Every DD correctly simulated by any HH of the infinite set of HH/DD
pairs that match the above template never reaches past its own simulated
line 03 in 1 to ∞ steps of correct simulation of DD by HH.

 But since the simulation was aborted, it doen't say anything about the halting status of the machine being simulated.
 PERID.
 Try to prove me wrong. Remember, HALTING is a property of the MACHINE (the PROGRAM EXECUTED, not simulated).
 

>
*THIS PROVES THAT THE INPUT TO H(DD,DD) DOES NOT HALT*
*THIS PROVES THAT THE INPUT TO H(DD,DD) DOES NOT HALT*
*THIS PROVES THAT THE INPUT TO H(DD,DD) DOES NOT HALT*
*THIS PROVES THAT THE INPUT TO H(DD,DD) DOES NOT HALT*

 No it does not.
 Because Halting is a property of the MACHINE DESCRIBED, not the partial simulaiton by H. you partial simulation show NOTHING.
 

>
The reason why the behavior of D(D) is irrelevant can
be discussed ONLY AFTER WE GET CLOSURE ON THE ABOVE POINT.

 Nope, because you said above that the input to HH(DD,DD) does not halt, and that is a statment about the machine/program DD, not its simulation.
 

>
*You have dishonestly dodged every single point for three years*
*You have dishonestly dodged every single point for three years*
*You have dishonestly dodged every single point for three years*
*You have dishonestly dodged every single point for three years*
>

 Nope, YOU have made you ignorantly dishonest claims on every point for appparently the last 20 years.
 You just don't know what you words actually mean, because it seems you just have lost all contact with reality due to your brainwashing yourself to believe your own lies.

Show me where I said anything in the above spec about an aborted simulation.
When every possible which way DD correctly simulated by HH never reaches
past its own simulated line 03 then
*THIS PROVES THAT THE INPUT TO H(DD,DD) DOES NOT HALT*
*THIS PROVES THAT THE INPUT TO H(DD,DD) DOES NOT HALT*
*THIS PROVES THAT THE INPUT TO H(DD,DD) DOES NOT HALT*
*THIS PROVES THAT THE INPUT TO H(DD,DD) DOES NOT HALT*
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer