On 3/22/2022 12:18 PM, wij wrote:
> On Wednesday, 23 March 2022 at 00:57:47 UTC+8, olcott wrote:
>> On 3/20/2022 2:25 PM, André G. Isaak wrote:
>>> On 2022-03-20 13:12, olcott wrote:
>>>> On 3/20/2022 1:59 PM, André G. Isaak wrote:
>>>>> I'm reposting the following question in this thread at Olcott's
>>>>> insistence even though it doesn't belong here. The original message
>>>>> can be seen in its proper context here: <t164qe$59o$2...@dont-email.me>
>>>>>
>>>>> On 2022-03-19 20:47, olcott wrote:
>>>>> > On 3/19/2022 9:38 PM, André G. Isaak wrote:
>>>>>
>>>>> > I changed to a different thread that does not have the lame main
>>>>> > thread name of Comic.
>>>>> >
>>>>> >> A Turing Machine has no access to *any* information apart from what
>>>>> >> is present on its tape. Ĥ (of which your embedded_H is a part)
>>>>> starts
>>>>> >> with only a *single* string on its tape.
>>>>> >>
>>>>> >> With what, exactly, do you plan on comparing this string in making
>>>>> >> your 'halt status decision'?
>>>>>
>>>>> You didn't actually answer the above question. What exactly do you
>>>>> plan on comparing the input to?
>>>>>
>>>>> André
>>>>
>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>> Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then embedded_H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>>>
>>>> Then these steps would keep repeating:
>>>> Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>> Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>> Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H2 simulates ⟨Ĥ3⟩
>>>> ⟨Ĥ4⟩...
>>>>
>>>> Technically the abort criteria exists when embedded_H0 would simulate
>>>> ⟨Ĥ1⟩ ⟨Ĥ2⟩. It is at this point that embedded_H would otherwise
>>>> simulate an exact copy of itself with an exact copy of its inputs.
>>>>
>>>> If embedded_H aborts the simulation of embedded_H0 before embedded_H0
>>>> is invoked then not even the first copy does the same thing as
>>>> embedded_H and there are no copies besides this first one.
>>>>
>>>> That the infinitely nested simulation criteria is definitively met
>>>> conclusively proves that embedded_H can reject its input without
>>>> forming the contradiction that Linz claims is formed.
>>>
>>>
>>> How does any of the above even remotely address the question I asked?
>>>
>>> You claimed "strcmp()" played an important role in your halting
>>> decision. (Your exact words were "When strcmp is used as the key element
>>> of a halt status decision then this changes the behavior H relative to
>>> embedded_H for the same input")
>>>
>>> Putting aside the fact that strcmp() is a C function which has nothing
>>> to do with Turing machines, string comparison requires *two* strings to
>>> compare. Ĥ takes a *single* string as its input so there is only one
>>> string on the tape. What do you plan on comparing this string with?
>>>
>>> André
>>>
>>
>> When Ĥ is applied to ⟨Ĥ⟩
>> Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then embedded_H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>
>> Then these steps would keep repeating:
>> Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>> Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>> Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H2 simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩...
>> We can see that an identical finite string of embedded_H continues to be
>> simulated with identical finite string inputs. **
>>
>> This tells us that Ĥ applied to ⟨Ĥ⟩ does specify infinitely nested
>> simulation to the original directly executed embedded_H.
>>
>> This is all that we need to refute the Linz conclusion that a that a
>> transition to Ĥ.qn necessarily results in a contradiction.
>>
>>
>>
>>
>> To prove that the input to embedded_H is decidable we need to know the
>> algorithm that embedded_H would use. All that this algorithm must do is
>> recognize the same pattern that we can see. That we can see this pattern
>> proves that recognizing this pattern is not categorically impossible.
>>
>> I could not show the details of recognizing this pattern using actual
>> Turing machines because it is enormously too tedious. Even the details
>> of calculating the digits of PI would be far too cumbersome for hardly
>> anyone to understand when these details are actual Turing machine state
>> transitions.
>
> It doesn't matter what programming language you use, you just do not have a real
> H and P but talk that you have.
>

Then I will do this in my x86 system as soon as the progress that I have
(refuing the Linz conclusion) already made is acknowledged.

>> The rational approach would be to specify the algorithm in some higher
>> level abstraction such as a RASP machine and then map this higher level
>> abstraction to a Turing machine description.
>>
>>
>>
>> ** A finite string comparison can also see that these finite string are
>> identical. All of these finite strings are somewhere on the tape of the
>> UTM that is a part of the original executed not simulated embedded_H,
>> thus available to this embedded_H.
>>
>> THE KEY POINT IS THAT THE LINZ CONCLUSION (THAT A TRANSITION TO Ĥ.QN
>> DERIVES A CONTRADICTION) IS REFUTED BY WHAT WE ALREADY KNOW.
>>
>> TO PROVE THAT THE HALTING PROBLEM COUNTER-EXAMPLE INPUTS ARE DECIDABLE
>> REQUIRES KNOWING THE ALGORITHM BASIS.
>> --
>> Copyright 2021 Pete Olcott
>>
>> Talent hits a target no one else can hit;
>> Genius hits a target no one else can see.
>> Arthur Schopenhauer
>
> H is a deterministic system (https://en.wikipedia.org/wiki/Deterministic_system)
> No H can correctly decide (halt at y or n state) the test case P:
>
> void P() { > if H(P) { for(;;) {}; }
> }
>
> 1. You don't have such H.
> Where is the claimed H these years? (just talks)
> 2. You don't even have a correct implement of the P above, neither.
> Your version is wrong. the "H(P)" in P is difficult to implement. (no one think you can do it right)

I have already done this.

// Simplified Linz Ĥ (Linz:1990:319)
// Strachey(1965) CPL translated to C
void P(u32 x)
{ if (H(x, x))HERE:
goto HERE;
}

int main()
{ Output("Input_Halts = ", H((u32)P, (u32)P));
}

https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer

On 3/22/22 1:33 PM, olcott wrote:
> On 3/22/2022 12:18 PM, wij wrote:
>> On Wednesday, 23 March 2022 at 00:57:47 UTC+8, olcott wrote:
>>> On 3/20/2022 2:25 PM, André G. Isaak wrote:
>>>> On 2022-03-20 13:12, olcott wrote:
>>>>> On 3/20/2022 1:59 PM, André G. Isaak wrote:
>>>>>> I'm reposting the following question in this thread at Olcott's
>>>>>> insistence even though it doesn't belong here. The original message
>>>>>> can be seen in its proper context here:
>>>>>> <t164qe$59o$2...@dont-email.me>
>>>>>>
>>>>>> On 2022-03-19 20:47, olcott wrote:
>>>>>>   > On 3/19/2022 9:38 PM, André G. Isaak wrote:
>>>>>>
>>>>>>   > I changed to a different thread that does not have the lame main
>>>>>>   > thread name of Comic.
>>>>>>   >
>>>>>>   >> A Turing Machine has no access to *any* information apart
>>>>>> from what
>>>>>>   >> is present on its tape. Ĥ (of which your embedded_H is a part)
>>>>>> starts
>>>>>>   >> with only a *single* string on its tape.
>>>>>>   >>
>>>>>>   >> With what, exactly, do you plan on comparing this string in
>>>>>> making
>>>>>>   >> your 'halt status decision'?
>>>>>>
>>>>>> You didn't actually answer the above question. What exactly do you
>>>>>> plan on comparing the input to?
>>>>>>
>>>>>> André
>>>>>
>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>     Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then embedded_H simulates ⟨Ĥ0⟩
>>>>> ⟨Ĥ1⟩
>>>>>
>>>>> Then these steps would keep repeating:
>>>>>     Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H0 simulates
>>>>> ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>     Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H1 simulates
>>>>> ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>     Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H2 simulates ⟨Ĥ3⟩
>>>>> ⟨Ĥ4⟩...
>>>>>
>>>>> Technically the abort criteria exists when embedded_H0 would simulate
>>>>> ⟨Ĥ1⟩ ⟨Ĥ2⟩. It is at this point that embedded_H would otherwise
>>>>> simulate an exact copy of itself with an exact copy of its inputs.
>>>>>
>>>>> If embedded_H aborts the simulation of embedded_H0 before embedded_H0
>>>>> is invoked then not even the first copy does the same thing as
>>>>> embedded_H and there are no copies besides this first one.
>>>>>
>>>>> That the infinitely nested simulation criteria is definitively met
>>>>> conclusively proves that embedded_H can reject its input without
>>>>> forming the contradiction that Linz claims is formed.
>>>>
>>>>
>>>> How does any of the above even remotely address the question I asked?
>>>>
>>>> You claimed "strcmp()" played an important role in your halting
>>>> decision. (Your exact words were "When strcmp is used as the key
>>>> element
>>>> of a halt status decision then this changes the behavior H relative to
>>>> embedded_H for the same input")
>>>>
>>>> Putting aside the fact that strcmp() is a C function which has nothing
>>>> to do with Turing machines, string comparison requires *two* strings to
>>>> compare. Ĥ takes a *single* string as its input so there is only one
>>>> string on the tape. What do you plan on comparing this string with?
>>>>
>>>> André
>>>>
>>>
>>> When Ĥ is applied to ⟨Ĥ⟩
>>> Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then embedded_H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>>
>>> Then these steps would keep repeating:
>>> Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>> Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>> Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H2 simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩...
>>> We can see that an identical finite string of embedded_H continues to be
>>> simulated with identical finite string inputs. **
>>>
>>> This tells us that Ĥ applied to ⟨Ĥ⟩ does specify infinitely nested
>>> simulation to the original directly executed embedded_H.
>>>
>>> This is all that we need to refute the Linz conclusion that a that a
>>> transition to Ĥ.qn necessarily results in a contradiction.
>>>
>>>
>>>
>>>
>>> To prove that the input to embedded_H is decidable we need to know the
>>> algorithm that embedded_H would use. All that this algorithm must do is
>>> recognize the same pattern that we can see. That we can see this pattern
>>> proves that recognizing this pattern is not categorically impossible.
>>>
>>> I could not show the details of recognizing this pattern using actual
>>> Turing machines because it is enormously too tedious. Even the details
>>> of calculating the digits of PI would be far too cumbersome for hardly
>>> anyone to understand when these details are actual Turing machine state
>>> transitions.
>>
>> It doesn't matter what programming language you use, you just do not
>> have a real
>> H and P but talk that you have.
>>
>
> Then I will do this in my x86 system as soon as the progress that I have
> (refuing the Linz conclusion) already made is acknowledged.

WHAT PROGRESS?

All you have done is proved you don't understand Turing Machines, Formal
Logic, or Truth (among many other things).

YOU think you have shown something, because you stick your fingers in
your ears and say "I CAN'T HEAR YOU" to the CORRECT rebuttals of your
garbage.

FAIL.

>
>>> The rational approach would be to specify the algorithm in some higher
>>> level abstraction such as a RASP machine and then map this higher level
>>> abstraction to a Turing machine description.
>>>
>>>
>>>
>>> ** A finite string comparison can also see that these finite string are
>>> identical. All of these finite strings are somewhere on the tape of the
>>> UTM that is a part of the original executed not simulated embedded_H,
>>> thus available to this embedded_H.
>>>
>>> THE KEY POINT IS THAT THE LINZ CONCLUSION (THAT A TRANSITION TO Ĥ.QN
>>> DERIVES A CONTRADICTION) IS REFUTED BY WHAT WE ALREADY KNOW.
>>>
>>> TO PROVE THAT THE HALTING PROBLEM COUNTER-EXAMPLE INPUTS ARE DECIDABLE
>>> REQUIRES KNOWING THE ALGORITHM BASIS.
>>> --
>>> Copyright 2021 Pete Olcott
>>>
>>> Talent hits a target no one else can hit;
>>> Genius hits a target no one else can see.
>>> Arthur Schopenhauer
>>
>> H is a deterministic system
>> (https://en.wikipedia.org/wiki/Deterministic_system)
>> No H can correctly decide (halt at y or n state) the test case P:
>>
>> void P() { >   if H(P) { for(;;) {}; }
>> }
>>
>> 1. You don't have such H.
>>   Where is the claimed H these years? (just talks)
>> 2. You don't even have a correct implement of the P above, neither.
>>   Your version is wrong. the "H(P)" in P is difficult to implement.
>> (no one think you can do it right)
>
> I have already done this.
>
> // Simplified Linz Ĥ (Linz:1990:319)
> // Strachey(1965) CPL translated to C
> void P(u32 x)
> {
>   if (H(x, x))HERE:
>     goto HERE;
> }
>
> int main()
> {
>   Output("Input_Halts = ", H((u32)P, (u32)P));
> }
>
>
> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
>

Which says that your program says the input doesn't halt (Halts = 0)

But change the program to:

int main()
{ Output("Input_Halts = ", H((u32)P, (u32)P);
P((u32)P);
Output("P Halted");
}

you should find that both lines get printed unless you system cheats
(like H isn't actually a computation), as if call in main of H(P,P)
returns 0, so must the call in P of H(P,P) and thus P will return.

On Wednesday, 23 March 2022 at 01:33:25 UTC+8, olcott wrote:
>...
> > 1. You don't have such H.
> > Where is the claimed H these years? (just talks)
> > 2. You don't even have a correct implement of the P above, neither.
> > Your version is wrong. the "H(P)" in P is difficult to implement. (no one think you can do it right)
>
> I have already done this.
>
> // Simplified Linz Ĥ (Linz:1990:319)
> // Strachey(1965) CPL translated to C
> void P(u32 x)
> {
> if (H(x, x))HERE:
> goto HERE;
> }
>
> int main()
> {
> Output("Input_Halts = ", H((u32)P, (u32)P));
> }
>
>
> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation

If H does not exist, how can P exist?

You have been talking about a non-existent H for many years.

On 3/22/2022 9:20 PM, wij wrote:
> On Wednesday, 23 March 2022 at 01:33:25 UTC+8, olcott wrote:
>> ...
>>> 1. You don't have such H.
>>> Where is the claimed H these years? (just talks)
>>> 2. You don't even have a correct implement of the P above, neither.
>>> Your version is wrong. the "H(P)" in P is difficult to implement. (no one think you can do it right)
>>
>> I have already done this.
>>
>> // Simplified Linz Ĥ (Linz:1990:319)
>> // Strachey(1965) CPL translated to C
>> void P(u32 x)
>> {
>> if (H(x, x))HERE:
>> goto HERE;
>> }
>>
>> int main()
>> {
>> Output("Input_Halts = ", H((u32)P, (u32)P));
>> }
>>
>>
>> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
>
> If H does not exist, how can P exist?
>
> You have been talking about a non-existent H for many years.

That H has been fully operational for many months.

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer

On Wednesday, 23 March 2022 at 10:30:07 UTC+8, olcott wrote:
> On 3/22/2022 9:20 PM, wij wrote:
> > On Wednesday, 23 March 2022 at 01:33:25 UTC+8, olcott wrote:
> >> ...
> >>> 1. You don't have such H.
> >>> Where is the claimed H these years? (just talks)
> >>> 2. You don't even have a correct implement of the P above, neither.
> >>> Your version is wrong. the "H(P)" in P is difficult to implement. (no one think you can do it right)
> >>
> >> I have already done this.
> >>
> >> // Simplified Linz Ĥ (Linz:1990:319)
> >> // Strachey(1965) CPL translated to C
> >> void P(u32 x)
> >> {
> >> if (H(x, x))HERE:
> >> goto HERE;
> >> }
> >>
> >> int main()
> >> {
> >> Output("Input_Halts = ", H((u32)P, (u32)P));
> >> }
> >>
> >>
> >> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
> >
> > If H does not exist, how can P exist?
> >
> > You have been talking about a non-existent H for many years.
> That H has been fully operational for many months.
> --
> Copyright 2021 Pete Olcott
>
> Talent hits a target no one else can hit;
> Genius hits a target no one else can see.
> Arthur Schopenhauer

Nop, you lied since the dawn of time. There is never such H as claimed.
You are always talking about something does not exist.

On 3/22/22 10:29 PM, olcott wrote:
> On 3/22/2022 9:20 PM, wij wrote:
>> On Wednesday, 23 March 2022 at 01:33:25 UTC+8, olcott wrote:
>>> ...
>>>> 1. You don't have such H.
>>>> Where is the claimed H these years? (just talks)
>>>> 2. You don't even have a correct implement of the P above, neither.
>>>> Your version is wrong. the "H(P)" in P is difficult to implement.
>>>> (no one think you can do it right)
>>>
>>> I have already done this.
>>>
>>> // Simplified Linz Ĥ (Linz:1990:319)
>>> // Strachey(1965) CPL translated to C
>>> void P(u32 x)
>>> {
>>> if (H(x, x))HERE:
>>> goto HERE;
>>> }
>>>
>>> int main()
>>> {
>>> Output("Input_Halts = ", H((u32)P, (u32)P));
>>> }
>>>
>>>
>>> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
>>>
>>
>> If H does not exist, how can P exist?
>>
>> You have been talking about a non-existent H for many years.
>
> That H has been fully operational for many months.
>

Except that it still gives the wrong answer, so I suppose that depends
on your definition of 'Operational'.

On 3/22/2022 9:37 PM, wij wrote:
> On Wednesday, 23 March 2022 at 10:30:07 UTC+8, olcott wrote:
>> On 3/22/2022 9:20 PM, wij wrote:
>>> On Wednesday, 23 March 2022 at 01:33:25 UTC+8, olcott wrote:
>>>> ...
>>>>> 1. You don't have such H.
>>>>> Where is the claimed H these years? (just talks)
>>>>> 2. You don't even have a correct implement of the P above, neither.
>>>>> Your version is wrong. the "H(P)" in P is difficult to implement. (no one think you can do it right)
>>>>
>>>> I have already done this.
>>>>
>>>> // Simplified Linz Ĥ (Linz:1990:319)
>>>> // Strachey(1965) CPL translated to C
>>>> void P(u32 x)
>>>> {
>>>> if (H(x, x))HERE:
>>>> goto HERE;
>>>> }
>>>>
>>>> int main()
>>>> {
>>>> Output("Input_Halts = ", H((u32)P, (u32)P));
>>>> }
>>>>
>>>>
>>>> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
>>>
>>> If H does not exist, how can P exist?
>>>
>>> You have been talking about a non-existent H for many years.
>> That H has been fully operational for many months.
>> --
>> Copyright 2021 Pete Olcott
>>
>> Talent hits a target no one else can hit;
>> Genius hits a target no one else can see.
>> Arthur Schopenhauer
>
> Nop, you lied since the dawn of time. There is never such H as claimed.
> You are always talking about something does not exist.

If my H is incorrect then an error could be found.

It is the case the my H does correctly determine that P never meets the
Linz definition of a halting computation: reaches a final state.

If you understand the x86 language you can see by the provided execution
trace that H is correct.

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer

On Wednesday, 23 March 2022 at 10:44:20 UTC+8, olcott wrote:
> On 3/22/2022 9:37 PM, wij wrote:
> > On Wednesday, 23 March 2022 at 10:30:07 UTC+8, olcott wrote:
> >> On 3/22/2022 9:20 PM, wij wrote:
> >>> On Wednesday, 23 March 2022 at 01:33:25 UTC+8, olcott wrote:
> >>>> ...
> >>>>> 1. You don't have such H.
> >>>>> Where is the claimed H these years? (just talks)
> >>>>> 2. You don't even have a correct implement of the P above, neither.
> >>>>> Your version is wrong. the "H(P)" in P is difficult to implement. (no one think you can do it right)
> >>>>
> >>>> I have already done this.
> >>>>
> >>>> // Simplified Linz Ĥ (Linz:1990:319)
> >>>> // Strachey(1965) CPL translated to C
> >>>> void P(u32 x)
> >>>> {
> >>>> if (H(x, x))HERE:
> >>>> goto HERE;
> >>>> }
> >>>>
> >>>> int main()
> >>>> {
> >>>> Output("Input_Halts = ", H((u32)P, (u32)P));
> >>>> }
> >>>>
> >>>>
> >>>> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
> >>>
> >>> If H does not exist, how can P exist?
> >>>
> >>> You have been talking about a non-existent H for many years.
> >> That H has been fully operational for many months.
> >> --
> >> Copyright 2021 Pete Olcott
> >>
> >> Talent hits a target no one else can hit;
> >> Genius hits a target no one else can see.
> >> Arthur Schopenhauer
> >
> > Nop, you lied since the dawn of time. There is never such H as claimed.
> > You are always talking about something does not exist.
> If my H is incorrect then an error could be found.

It does not exist !!!
You have indicated that your H is done 'manually'. (not algorithmically)

> It is the case the my H does correctly determine that P never meets the
> Linz definition of a halting computation: reaches a final state.
>
> If you understand the x86 language you can see by the provided execution
> trace that H is correct.
> --

And now, you provided it 'verbally'.
People had requested you to show your H many times, you always find reason not to,
even CHANGE your theory again and again.
Is it fair to call you a liar?

On 3/22/2022 10:01 PM, wij wrote:
> On Wednesday, 23 March 2022 at 10:44:20 UTC+8, olcott wrote:
>> On 3/22/2022 9:37 PM, wij wrote:
>>> On Wednesday, 23 March 2022 at 10:30:07 UTC+8, olcott wrote:
>>>> On 3/22/2022 9:20 PM, wij wrote:
>>>>> On Wednesday, 23 March 2022 at 01:33:25 UTC+8, olcott wrote:
>>>>>> ...
>>>>>>> 1. You don't have such H.
>>>>>>> Where is the claimed H these years? (just talks)
>>>>>>> 2. You don't even have a correct implement of the P above, neither.
>>>>>>> Your version is wrong. the "H(P)" in P is difficult to implement. (no one think you can do it right)
>>>>>>
>>>>>> I have already done this.
>>>>>>
>>>>>> // Simplified Linz Ĥ (Linz:1990:319)
>>>>>> // Strachey(1965) CPL translated to C
>>>>>> void P(u32 x)
>>>>>> {
>>>>>> if (H(x, x))HERE:
>>>>>> goto HERE;
>>>>>> }
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>> Output("Input_Halts = ", H((u32)P, (u32)P));
>>>>>> }
>>>>>>
>>>>>>
>>>>>> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
>>>>>
>>>>> If H does not exist, how can P exist?
>>>>>
>>>>> You have been talking about a non-existent H for many years.
>>>> That H has been fully operational for many months.
>>>> --
>>>> Copyright 2021 Pete Olcott
>>>>
>>>> Talent hits a target no one else can hit;
>>>> Genius hits a target no one else can see.
>>>> Arthur Schopenhauer
>>>
>>> Nop, you lied since the dawn of time. There is never such H as claimed.
>>> You are always talking about something does not exist.
>> If my H is incorrect then an error could be found.
>
> It does not exist !!!
> You have indicated that your H is done 'manually'. (not algorithmically)

My C/x86 H/P combination is fully operational software based on a very
powerful x86 emulator.

>
>> It is the case the my H does correctly determine that P never meets the
>> Linz definition of a halting computation: reaches a final state.
>>
>> If you understand the x86 language you can see by the provided execution
>> trace that H is correct.
>> --
>
> And now, you provided it 'verbally'.
> People had requested you to show your H many times, you always find reason not to,
> even CHANGE your theory again and again.
> Is it fair to call you a liar?

The execution trace of H correctly deciding the halt status is shown in
this paper:

https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation

When H(P,P) continues to be invoked with identical input this
conclusively proves that it is invoked in infinitely nested simulation
that can never reach the final state of [00000c50] (and thus halt)
whether or not this simulation is aborted.

Because the execution trace is so very obviously self-evidently correct
all the calls to see the source code were ruse.

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer

On Wednesday, 23 March 2022 at 11:10:43 UTC+8, olcott wrote:
> On 3/22/2022 10:01 PM, wij wrote:
> > On Wednesday, 23 March 2022 at 10:44:20 UTC+8, olcott wrote:
> >> On 3/22/2022 9:37 PM, wij wrote:
> >>> On Wednesday, 23 March 2022 at 10:30:07 UTC+8, olcott wrote:
> >>>> On 3/22/2022 9:20 PM, wij wrote:
> >>>>> On Wednesday, 23 March 2022 at 01:33:25 UTC+8, olcott wrote:
> >>>>>> ...
> >>>>>>> 1. You don't have such H.
> >>>>>>> Where is the claimed H these years? (just talks)
> >>>>>>> 2. You don't even have a correct implement of the P above, neither.
> >>>>>>> Your version is wrong. the "H(P)" in P is difficult to implement. (no one think you can do it right)
> >>>>>>
> >>>>>> I have already done this.
> >>>>>>
> >>>>>> // Simplified Linz Ĥ (Linz:1990:319)
> >>>>>> // Strachey(1965) CPL translated to C
> >>>>>> void P(u32 x)
> >>>>>> {
> >>>>>> if (H(x, x))HERE:
> >>>>>> goto HERE;
> >>>>>> }
> >>>>>>
> >>>>>> int main()
> >>>>>> {
> >>>>>> Output("Input_Halts = ", H((u32)P, (u32)P));
> >>>>>> }
> >>>>>>
> >>>>>>
> >>>>>> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
> >>>>>
> >>>>> If H does not exist, how can P exist?
> >>>>>
> >>>>> You have been talking about a non-existent H for many years.
> >>>> That H has been fully operational for many months.
> >>>> --
> >>>> Copyright 2021 Pete Olcott
> >>>>
> >>>> Talent hits a target no one else can hit;
> >>>> Genius hits a target no one else can see.
> >>>> Arthur Schopenhauer
> >>>
> >>> Nop, you lied since the dawn of time. There is never such H as claimed.
> >>> You are always talking about something does not exist.
> >> If my H is incorrect then an error could be found.
> >
> > It does not exist !!!
> > You have indicated that your H is done 'manually'. (not algorithmically)
> My C/x86 H/P combination is fully operational software based on a very
> powerful x86 emulator.
> >
> >> It is the case the my H does correctly determine that P never meets the
> >> Linz definition of a halting computation: reaches a final state.
> >>
> >> If you understand the x86 language you can see by the provided execution
> >> trace that H is correct.
> >> --
> >
> > And now, you provided it 'verbally'.
> > People had requested you to show your H many times, you always find reason not to,
> > even CHANGE your theory again and again.
> > Is it fair to call you a liar?
> The execution trace of H correctly deciding the halt status is shown in
> this paper:
>
> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
>
> When H(P,P) continues to be invoked with identical input this
> conclusively proves that it is invoked in infinitely nested simulation
> that can never reach the final state of [00000c50] (and thus halt)
> whether or not this simulation is aborted.
>
> Because the execution trace is so very obviously self-evidently correct
> all the calls to see the source code were ruse.
> --
> Copyright 2021 Pete Olcott
>
> Talent hits a target no one else can hit;
> Genius hits a target no one else can see.
> Arthur Schopenhauer

By now, no one believes what you say. You have to prove it non-verbally.
You call a complete proof 'ruse'?
Anybody can use the the same code fragment shown to 'prove' the opposite.

Where is code executing 'halt' and 'abort' (the final decision)?
You have indicated that your H is done 'manually'. Show it all, so we know
it is done algorithmically.

On 3/22/2022 10:36 PM, wij wrote:
> On Wednesday, 23 March 2022 at 11:10:43 UTC+8, olcott wrote:
>> On 3/22/2022 10:01 PM, wij wrote:
>>> On Wednesday, 23 March 2022 at 10:44:20 UTC+8, olcott wrote:
>>>> On 3/22/2022 9:37 PM, wij wrote:
>>>>> On Wednesday, 23 March 2022 at 10:30:07 UTC+8, olcott wrote:
>>>>>> On 3/22/2022 9:20 PM, wij wrote:
>>>>>>> On Wednesday, 23 March 2022 at 01:33:25 UTC+8, olcott wrote:
>>>>>>>> ...
>>>>>>>>> 1. You don't have such H.
>>>>>>>>> Where is the claimed H these years? (just talks)
>>>>>>>>> 2. You don't even have a correct implement of the P above, neither.
>>>>>>>>> Your version is wrong. the "H(P)" in P is difficult to implement. (no one think you can do it right)
>>>>>>>>
>>>>>>>> I have already done this.
>>>>>>>>
>>>>>>>> // Simplified Linz Ĥ (Linz:1990:319)
>>>>>>>> // Strachey(1965) CPL translated to C
>>>>>>>> void P(u32 x)
>>>>>>>> {
>>>>>>>> if (H(x, x))HERE:
>>>>>>>> goto HERE;
>>>>>>>> }
>>>>>>>>
>>>>>>>> int main()
>>>>>>>> {
>>>>>>>> Output("Input_Halts = ", H((u32)P, (u32)P));
>>>>>>>> }
>>>>>>>>
>>>>>>>>
>>>>>>>> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
>>>>>>>
>>>>>>> If H does not exist, how can P exist?
>>>>>>>
>>>>>>> You have been talking about a non-existent H for many years.
>>>>>> That H has been fully operational for many months.
>>>>>> --
>>>>>> Copyright 2021 Pete Olcott
>>>>>>
>>>>>> Talent hits a target no one else can hit;
>>>>>> Genius hits a target no one else can see.
>>>>>> Arthur Schopenhauer
>>>>>
>>>>> Nop, you lied since the dawn of time. There is never such H as claimed.
>>>>> You are always talking about something does not exist.
>>>> If my H is incorrect then an error could be found.
>>>
>>> It does not exist !!!
>>> You have indicated that your H is done 'manually'. (not algorithmically)
>> My C/x86 H/P combination is fully operational software based on a very
>> powerful x86 emulator.
>>>
>>>> It is the case the my H does correctly determine that P never meets the
>>>> Linz definition of a halting computation: reaches a final state.
>>>>
>>>> If you understand the x86 language you can see by the provided execution
>>>> trace that H is correct.
>>>> --
>>>
>>> And now, you provided it 'verbally'.
>>> People had requested you to show your H many times, you always find reason not to,
>>> even CHANGE your theory again and again.
>>> Is it fair to call you a liar?
>> The execution trace of H correctly deciding the halt status is shown in
>> this paper:
>>
>> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
>>
>> When H(P,P) continues to be invoked with identical input this
>> conclusively proves that it is invoked in infinitely nested simulation
>> that can never reach the final state of [00000c50] (and thus halt)
>> whether or not this simulation is aborted.
>>
>> Because the execution trace is so very obviously self-evidently correct
>> all the calls to see the source code were ruse.
>> --
>> Copyright 2021 Pete Olcott
>>
>> Talent hits a target no one else can hit;
>> Genius hits a target no one else can see.
>> Arthur Schopenhauer
>
> By now, no one believes what you say.

Which is no actual rebuttal what-so-ever.
Prior to Pythagoras everyone knew that the Earth was flat.

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer

On Wednesday, 23 March 2022 at 11:53:24 UTC+8, olcott wrote:
> On 3/22/2022 10:36 PM, wij wrote:
> > On Wednesday, 23 March 2022 at 11:10:43 UTC+8, olcott wrote:
> >> On 3/22/2022 10:01 PM, wij wrote:
> >>> On Wednesday, 23 March 2022 at 10:44:20 UTC+8, olcott wrote:
> >>>> On 3/22/2022 9:37 PM, wij wrote:
> >>>>> On Wednesday, 23 March 2022 at 10:30:07 UTC+8, olcott wrote:
> >>>>>> On 3/22/2022 9:20 PM, wij wrote:
> >>>>>>> On Wednesday, 23 March 2022 at 01:33:25 UTC+8, olcott wrote:
> >>>>>>>> ...
> >>>>>>>>> 1. You don't have such H.
> >>>>>>>>> Where is the claimed H these years? (just talks)
> >>>>>>>>> 2. You don't even have a correct implement of the P above, neither.
> >>>>>>>>> Your version is wrong. the "H(P)" in P is difficult to implement. (no one think you can do it right)
> >>>>>>>>
> >>>>>>>> I have already done this.
> >>>>>>>>
> >>>>>>>> // Simplified Linz Ĥ (Linz:1990:319)
> >>>>>>>> // Strachey(1965) CPL translated to C
> >>>>>>>> void P(u32 x)
> >>>>>>>> {
> >>>>>>>> if (H(x, x))HERE:
> >>>>>>>> goto HERE;
> >>>>>>>> }
> >>>>>>>>
> >>>>>>>> int main()
> >>>>>>>> {
> >>>>>>>> Output("Input_Halts = ", H((u32)P, (u32)P));
> >>>>>>>> }
> >>>>>>>>
> >>>>>>>>
> >>>>>>>> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
> >>>>>>>
> >>>>>>> If H does not exist, how can P exist?
> >>>>>>>
> >>>>>>> You have been talking about a non-existent H for many years.
> >>>>>> That H has been fully operational for many months.
> >>>>>> --
> >>>>>> Copyright 2021 Pete Olcott
> >>>>>>
> >>>>>> Talent hits a target no one else can hit;
> >>>>>> Genius hits a target no one else can see.
> >>>>>> Arthur Schopenhauer
> >>>>>
> >>>>> Nop, you lied since the dawn of time. There is never such H as claimed.
> >>>>> You are always talking about something does not exist.
> >>>> If my H is incorrect then an error could be found.
> >>>
> >>> It does not exist !!!
> >>> You have indicated that your H is done 'manually'. (not algorithmically)
> >> My C/x86 H/P combination is fully operational software based on a very
> >> powerful x86 emulator.
> >>>
> >>>> It is the case the my H does correctly determine that P never meets the
> >>>> Linz definition of a halting computation: reaches a final state.
> >>>>
> >>>> If you understand the x86 language you can see by the provided execution
> >>>> trace that H is correct.
> >>>> --
> >>>
> >>> And now, you provided it 'verbally'.
> >>> People had requested you to show your H many times, you always find reason not to,
> >>> even CHANGE your theory again and again.
> >>> Is it fair to call you a liar?
> >> The execution trace of H correctly deciding the halt status is shown in
> >> this paper:
> >>
> >> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
> >>
> >> When H(P,P) continues to be invoked with identical input this
> >> conclusively proves that it is invoked in infinitely nested simulation
> >> that can never reach the final state of [00000c50] (and thus halt)
> >> whether or not this simulation is aborted.
> >>
> >> Because the execution trace is so very obviously self-evidently correct
> >> all the calls to see the source code were ruse.
> >> --
> >> Copyright 2021 Pete Olcott
> >>
> >> Talent hits a target no one else can hit;
> >> Genius hits a target no one else can see.
> >> Arthur Schopenhauer
> >
> > By now, no one believes what you say.
> Which is no actual rebuttal what-so-ever.
> Prior to Pythagoras everyone knew that the Earth was flat.
> --
> Copyright 2021 Pete Olcott
>
> Talent hits a target no one else can hit;
> Genius hits a target no one else can see.
> Arthur Schopenhauer

You are trying to evade your error again.
Where is the complete proof?
Anybody can use the the same code fragment of yours to prove the opposite of
what you claim. E.g. "It is more so obviously self-evidently correct that H cannot return (undecidable)".
The code fragment shows infinitely calls, isn't it? Where does H return (or reach a final state)?

On 3/22/2022 11:06 PM, wij wrote:
> On Wednesday, 23 March 2022 at 11:53:24 UTC+8, olcott wrote:
>> On 3/22/2022 10:36 PM, wij wrote:
>>> On Wednesday, 23 March 2022 at 11:10:43 UTC+8, olcott wrote:
>>>> On 3/22/2022 10:01 PM, wij wrote:
>>>>> On Wednesday, 23 March 2022 at 10:44:20 UTC+8, olcott wrote:
>>>>>> On 3/22/2022 9:37 PM, wij wrote:
>>>>>>> On Wednesday, 23 March 2022 at 10:30:07 UTC+8, olcott wrote:
>>>>>>>> On 3/22/2022 9:20 PM, wij wrote:
>>>>>>>>> On Wednesday, 23 March 2022 at 01:33:25 UTC+8, olcott wrote:
>>>>>>>>>> ...
>>>>>>>>>>> 1. You don't have such H.
>>>>>>>>>>> Where is the claimed H these years? (just talks)
>>>>>>>>>>> 2. You don't even have a correct implement of the P above, neither.
>>>>>>>>>>> Your version is wrong. the "H(P)" in P is difficult to implement. (no one think you can do it right)
>>>>>>>>>>
>>>>>>>>>> I have already done this.
>>>>>>>>>>
>>>>>>>>>> // Simplified Linz Ĥ (Linz:1990:319)
>>>>>>>>>> // Strachey(1965) CPL translated to C
>>>>>>>>>> void P(u32 x)
>>>>>>>>>> {
>>>>>>>>>> if (H(x, x))HERE:
>>>>>>>>>> goto HERE;
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> int main()
>>>>>>>>>> {
>>>>>>>>>> Output("Input_Halts = ", H((u32)P, (u32)P));
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
>>>>>>>>>
>>>>>>>>> If H does not exist, how can P exist?
>>>>>>>>>
>>>>>>>>> You have been talking about a non-existent H for many years.
>>>>>>>> That H has been fully operational for many months.
>>>>>>>> --
>>>>>>>> Copyright 2021 Pete Olcott
>>>>>>>>
>>>>>>>> Talent hits a target no one else can hit;
>>>>>>>> Genius hits a target no one else can see.
>>>>>>>> Arthur Schopenhauer
>>>>>>>
>>>>>>> Nop, you lied since the dawn of time. There is never such H as claimed.
>>>>>>> You are always talking about something does not exist.
>>>>>> If my H is incorrect then an error could be found.
>>>>>
>>>>> It does not exist !!!
>>>>> You have indicated that your H is done 'manually'. (not algorithmically)
>>>> My C/x86 H/P combination is fully operational software based on a very
>>>> powerful x86 emulator.
>>>>>
>>>>>> It is the case the my H does correctly determine that P never meets the
>>>>>> Linz definition of a halting computation: reaches a final state.
>>>>>>
>>>>>> If you understand the x86 language you can see by the provided execution
>>>>>> trace that H is correct.
>>>>>> --
>>>>>
>>>>> And now, you provided it 'verbally'.
>>>>> People had requested you to show your H many times, you always find reason not to,
>>>>> even CHANGE your theory again and again.
>>>>> Is it fair to call you a liar?
>>>> The execution trace of H correctly deciding the halt status is shown in
>>>> this paper:
>>>>
>>>> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
>>>>
>>>> When H(P,P) continues to be invoked with identical input this
>>>> conclusively proves that it is invoked in infinitely nested simulation
>>>> that can never reach the final state of [00000c50] (and thus halt)
>>>> whether or not this simulation is aborted.
>>>>
>>>> Because the execution trace is so very obviously self-evidently correct
>>>> all the calls to see the source code were ruse.
>>>> --
>>>> Copyright 2021 Pete Olcott
>>>>
>>>> Talent hits a target no one else can hit;
>>>> Genius hits a target no one else can see.
>>>> Arthur Schopenhauer
>>>
>>> By now, no one believes what you say.
>> Which is no actual rebuttal what-so-ever.
>> Prior to Pythagoras everyone knew that the Earth was flat.
>> --
>> Copyright 2021 Pete Olcott
>>
>> Talent hits a target no one else can hit;
>> Genius hits a target no one else can see.
>> Arthur Schopenhauer
>
> You are trying to evade your error again.
> Where is the complete proof?

You must read rather than ignore this paper.
https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation

> Anybody can use the the same code fragment of yours to prove the opposite of
> what you claim. E.g. "It is more so obviously self-evidently correct that H cannot return (undecidable)".
> The code fragment shows infinitely calls, isn't it? Where does H return (or reach a final state)?

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer

On Wednesday, 23 March 2022 at 12:08:42 UTC+8, olcott wrote:
> On 3/22/2022 11:06 PM, wij wrote:
> > On Wednesday, 23 March 2022 at 11:53:24 UTC+8, olcott wrote:
> >> On 3/22/2022 10:36 PM, wij wrote:
> >>> On Wednesday, 23 March 2022 at 11:10:43 UTC+8, olcott wrote:
> >>>> On 3/22/2022 10:01 PM, wij wrote:
> >>>>> On Wednesday, 23 March 2022 at 10:44:20 UTC+8, olcott wrote:
> >>>>>> On 3/22/2022 9:37 PM, wij wrote:
> >>>>>>> On Wednesday, 23 March 2022 at 10:30:07 UTC+8, olcott wrote:
> >>>>>>>> On 3/22/2022 9:20 PM, wij wrote:
> >>>>>>>>> On Wednesday, 23 March 2022 at 01:33:25 UTC+8, olcott wrote:
> >>>>>>>>>> ...
> >>>>>>>>>>> 1. You don't have such H.
> >>>>>>>>>>> Where is the claimed H these years? (just talks)
> >>>>>>>>>>> 2. You don't even have a correct implement of the P above, neither.
> >>>>>>>>>>> Your version is wrong. the "H(P)" in P is difficult to implement. (no one think you can do it right)
> >>>>>>>>>>
> >>>>>>>>>> I have already done this.
> >>>>>>>>>>
> >>>>>>>>>> // Simplified Linz Ĥ (Linz:1990:319)
> >>>>>>>>>> // Strachey(1965) CPL translated to C
> >>>>>>>>>> void P(u32 x)
> >>>>>>>>>> {
> >>>>>>>>>> if (H(x, x))HERE:
> >>>>>>>>>> goto HERE;
> >>>>>>>>>> }
> >>>>>>>>>>
> >>>>>>>>>> int main()
> >>>>>>>>>> {
> >>>>>>>>>> Output("Input_Halts = ", H((u32)P, (u32)P));
> >>>>>>>>>> }
> >>>>>>>>>>
> >>>>>>>>>>
> >>>>>>>>>> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
> >>>>>>>>>
> >>>>>>>>> If H does not exist, how can P exist?
> >>>>>>>>>
> >>>>>>>>> You have been talking about a non-existent H for many years.
> >>>>>>>> That H has been fully operational for many months.
> >>>>>>>> --
> >>>>>>>> Copyright 2021 Pete Olcott
> >>>>>>>>
> >>>>>>>> Talent hits a target no one else can hit;
> >>>>>>>> Genius hits a target no one else can see.
> >>>>>>>> Arthur Schopenhauer
> >>>>>>>
> >>>>>>> Nop, you lied since the dawn of time. There is never such H as claimed.
> >>>>>>> You are always talking about something does not exist.
> >>>>>> If my H is incorrect then an error could be found.
> >>>>>
> >>>>> It does not exist !!!
> >>>>> You have indicated that your H is done 'manually'. (not algorithmically)
> >>>> My C/x86 H/P combination is fully operational software based on a very
> >>>> powerful x86 emulator.
> >>>>>
> >>>>>> It is the case the my H does correctly determine that P never meets the
> >>>>>> Linz definition of a halting computation: reaches a final state.
> >>>>>>
> >>>>>> If you understand the x86 language you can see by the provided execution
> >>>>>> trace that H is correct.
> >>>>>> --
> >>>>>
> >>>>> And now, you provided it 'verbally'.
> >>>>> People had requested you to show your H many times, you always find reason not to,
> >>>>> even CHANGE your theory again and again.
> >>>>> Is it fair to call you a liar?
> >>>> The execution trace of H correctly deciding the halt status is shown in
> >>>> this paper:
> >>>>
> >>>> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
> >>>>
> >>>> When H(P,P) continues to be invoked with identical input this
> >>>> conclusively proves that it is invoked in infinitely nested simulation
> >>>> that can never reach the final state of [00000c50] (and thus halt)
> >>>> whether or not this simulation is aborted.
> >>>>
> >>>> Because the execution trace is so very obviously self-evidently correct
> >>>> all the calls to see the source code were ruse.
> >>>> --
> >>>> Copyright 2021 Pete Olcott
> >>>>
> >>>> Talent hits a target no one else can hit;
> >>>> Genius hits a target no one else can see.
> >>>> Arthur Schopenhauer
> >>>
> >>> By now, no one believes what you say.
> >> Which is no actual rebuttal what-so-ever.
> >> Prior to Pythagoras everyone knew that the Earth was flat.
> >> --
> >> Copyright 2021 Pete Olcott
> >>
> >> Talent hits a target no one else can hit;
> >> Genius hits a target no one else can see.
> >> Arthur Schopenhauer
> >
> > You are trying to evade your error again.
> > Where is the complete proof?
> You must read rather than ignore this paper.
> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
> > Anybody can use the the same code fragment of yours to prove the opposite of
> > what you claim. E.g. "It is more so obviously self-evidently correct that H cannot return (undecidable)".
> > The code fragment shows infinitely calls, isn't it? Where does H return (or reach a final state)?
> --
> Copyright 2021 Pete Olcott
>
> Talent hits a target no one else can hit;
> Genius hits a target no one else can see.
> Arthur Schopenhauer

All shown to me is that you don't know what undecidability means.
You cannot evade the fate to provided a complete proof. Your code
fragment is at most partial (and trivial), says nothing to the point.
As said, this is not the first time, you always find reason not to show
your H. (because no such H ever existed).
Admit it to save our time.

On 3/22/2022 11:19 PM, wij wrote:
> On Wednesday, 23 March 2022 at 12:08:42 UTC+8, olcott wrote:
>> On 3/22/2022 11:06 PM, wij wrote:
>>> On Wednesday, 23 March 2022 at 11:53:24 UTC+8, olcott wrote:
>>>> On 3/22/2022 10:36 PM, wij wrote:
>>>>> On Wednesday, 23 March 2022 at 11:10:43 UTC+8, olcott wrote:
>>>>>> On 3/22/2022 10:01 PM, wij wrote:
>>>>>>> On Wednesday, 23 March 2022 at 10:44:20 UTC+8, olcott wrote:
>>>>>>>> On 3/22/2022 9:37 PM, wij wrote:
>>>>>>>>> On Wednesday, 23 March 2022 at 10:30:07 UTC+8, olcott wrote:
>>>>>>>>>> On 3/22/2022 9:20 PM, wij wrote:
>>>>>>>>>>> On Wednesday, 23 March 2022 at 01:33:25 UTC+8, olcott wrote:
>>>>>>>>>>>> ...
>>>>>>>>>>>>> 1. You don't have such H.
>>>>>>>>>>>>> Where is the claimed H these years? (just talks)
>>>>>>>>>>>>> 2. You don't even have a correct implement of the P above, neither.
>>>>>>>>>>>>> Your version is wrong. the "H(P)" in P is difficult to implement. (no one think you can do it right)
>>>>>>>>>>>>
>>>>>>>>>>>> I have already done this.
>>>>>>>>>>>>
>>>>>>>>>>>> // Simplified Linz Ĥ (Linz:1990:319)
>>>>>>>>>>>> // Strachey(1965) CPL translated to C
>>>>>>>>>>>> void P(u32 x)
>>>>>>>>>>>> {
>>>>>>>>>>>> if (H(x, x))HERE:
>>>>>>>>>>>> goto HERE;
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> int main()
>>>>>>>>>>>> {
>>>>>>>>>>>> Output("Input_Halts = ", H((u32)P, (u32)P));
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
>>>>>>>>>>>
>>>>>>>>>>> If H does not exist, how can P exist?
>>>>>>>>>>>
>>>>>>>>>>> You have been talking about a non-existent H for many years.
>>>>>>>>>> That H has been fully operational for many months.
>>>>>>>>>> --
>>>>>>>>>> Copyright 2021 Pete Olcott
>>>>>>>>>>
>>>>>>>>>> Talent hits a target no one else can hit;
>>>>>>>>>> Genius hits a target no one else can see.
>>>>>>>>>> Arthur Schopenhauer
>>>>>>>>>
>>>>>>>>> Nop, you lied since the dawn of time. There is never such H as claimed.
>>>>>>>>> You are always talking about something does not exist.
>>>>>>>> If my H is incorrect then an error could be found.
>>>>>>>
>>>>>>> It does not exist !!!
>>>>>>> You have indicated that your H is done 'manually'. (not algorithmically)
>>>>>> My C/x86 H/P combination is fully operational software based on a very
>>>>>> powerful x86 emulator.
>>>>>>>
>>>>>>>> It is the case the my H does correctly determine that P never meets the
>>>>>>>> Linz definition of a halting computation: reaches a final state.
>>>>>>>>
>>>>>>>> If you understand the x86 language you can see by the provided execution
>>>>>>>> trace that H is correct.
>>>>>>>> --
>>>>>>>
>>>>>>> And now, you provided it 'verbally'.
>>>>>>> People had requested you to show your H many times, you always find reason not to,
>>>>>>> even CHANGE your theory again and again.
>>>>>>> Is it fair to call you a liar?
>>>>>> The execution trace of H correctly deciding the halt status is shown in
>>>>>> this paper:
>>>>>>
>>>>>> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
>>>>>>
>>>>>> When H(P,P) continues to be invoked with identical input this
>>>>>> conclusively proves that it is invoked in infinitely nested simulation
>>>>>> that can never reach the final state of [00000c50] (and thus halt)
>>>>>> whether or not this simulation is aborted.
>>>>>>
>>>>>> Because the execution trace is so very obviously self-evidently correct
>>>>>> all the calls to see the source code were ruse.
>>>>>> --
>>>>>> Copyright 2021 Pete Olcott
>>>>>>
>>>>>> Talent hits a target no one else can hit;
>>>>>> Genius hits a target no one else can see.
>>>>>> Arthur Schopenhauer
>>>>>
>>>>> By now, no one believes what you say.
>>>> Which is no actual rebuttal what-so-ever.
>>>> Prior to Pythagoras everyone knew that the Earth was flat.
>>>> --
>>>> Copyright 2021 Pete Olcott
>>>>
>>>> Talent hits a target no one else can hit;
>>>> Genius hits a target no one else can see.
>>>> Arthur Schopenhauer
>>>
>>> You are trying to evade your error again.
>>> Where is the complete proof?
>> You must read rather than ignore this paper.
>> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
>>> Anybody can use the the same code fragment of yours to prove the opposite of
>>> what you claim. E.g. "It is more so obviously self-evidently correct that H cannot return (undecidable)".
>>> The code fragment shows infinitely calls, isn't it? Where does H return (or reach a final state)?
>> --
>> Copyright 2021 Pete Olcott
>>
>> Talent hits a target no one else can hit;
>> Genius hits a target no one else can see.
>> Arthur Schopenhauer
>
> All shown to me is that you don't know what undecidability means.

All you have shown is that you haven't bothered to read my paper yet.

> You cannot evade the fate to provided a complete proof. Your code
> fragment is at most partial (and trivial), says nothing to the point.
> As said, this is not the first time, you always find reason not to show
> your H. (because no such H ever existed).
> Admit it to save our time.

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer

On Wednesday, 23 March 2022 at 12:22:36 UTC+8, olcott wrote:
> On 3/22/2022 11:19 PM, wij wrote:
> > On Wednesday, 23 March 2022 at 12:08:42 UTC+8, olcott wrote:
> >> On 3/22/2022 11:06 PM, wij wrote:
> >>> On Wednesday, 23 March 2022 at 11:53:24 UTC+8, olcott wrote:
> >>>> On 3/22/2022 10:36 PM, wij wrote:
> >>>>> On Wednesday, 23 March 2022 at 11:10:43 UTC+8, olcott wrote:
> >>>>>> On 3/22/2022 10:01 PM, wij wrote:
> >>>>>>> On Wednesday, 23 March 2022 at 10:44:20 UTC+8, olcott wrote:
> >>>>>>>> On 3/22/2022 9:37 PM, wij wrote:
> >>>>>>>>> On Wednesday, 23 March 2022 at 10:30:07 UTC+8, olcott wrote:
> >>>>>>>>>> On 3/22/2022 9:20 PM, wij wrote:
> >>>>>>>>>>> On Wednesday, 23 March 2022 at 01:33:25 UTC+8, olcott wrote:
> >>>>>>>>>>>> ...
> >>>>>>>>>>>>> 1. You don't have such H.
> >>>>>>>>>>>>> Where is the claimed H these years? (just talks)
> >>>>>>>>>>>>> 2. You don't even have a correct implement of the P above, neither.
> >>>>>>>>>>>>> Your version is wrong. the "H(P)" in P is difficult to implement. (no one think you can do it right)
> >>>>>>>>>>>>
> >>>>>>>>>>>> I have already done this.
> >>>>>>>>>>>>
> >>>>>>>>>>>> // Simplified Linz Ĥ (Linz:1990:319)
> >>>>>>>>>>>> // Strachey(1965) CPL translated to C
> >>>>>>>>>>>> void P(u32 x)
> >>>>>>>>>>>> {
> >>>>>>>>>>>> if (H(x, x))HERE:
> >>>>>>>>>>>> goto HERE;
> >>>>>>>>>>>> }
> >>>>>>>>>>>>
> >>>>>>>>>>>> int main()
> >>>>>>>>>>>> {
> >>>>>>>>>>>> Output("Input_Halts = ", H((u32)P, (u32)P));
> >>>>>>>>>>>> }
> >>>>>>>>>>>>
> >>>>>>>>>>>>
> >>>>>>>>>>>> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
> >>>>>>>>>>>
> >>>>>>>>>>> If H does not exist, how can P exist?
> >>>>>>>>>>>
> >>>>>>>>>>> You have been talking about a non-existent H for many years.
> >>>>>>>>>> That H has been fully operational for many months.
> >>>>>>>>>> --
> >>>>>>>>>> Copyright 2021 Pete Olcott
> >>>>>>>>>>
> >>>>>>>>>> Talent hits a target no one else can hit;
> >>>>>>>>>> Genius hits a target no one else can see.
> >>>>>>>>>> Arthur Schopenhauer
> >>>>>>>>>
> >>>>>>>>> Nop, you lied since the dawn of time. There is never such H as claimed.
> >>>>>>>>> You are always talking about something does not exist.
> >>>>>>>> If my H is incorrect then an error could be found.
> >>>>>>>
> >>>>>>> It does not exist !!!
> >>>>>>> You have indicated that your H is done 'manually'. (not algorithmically)
> >>>>>> My C/x86 H/P combination is fully operational software based on a very
> >>>>>> powerful x86 emulator.
> >>>>>>>
> >>>>>>>> It is the case the my H does correctly determine that P never meets the
> >>>>>>>> Linz definition of a halting computation: reaches a final state.
> >>>>>>>>
> >>>>>>>> If you understand the x86 language you can see by the provided execution
> >>>>>>>> trace that H is correct.
> >>>>>>>> --
> >>>>>>>
> >>>>>>> And now, you provided it 'verbally'.
> >>>>>>> People had requested you to show your H many times, you always find reason not to,
> >>>>>>> even CHANGE your theory again and again.
> >>>>>>> Is it fair to call you a liar?
> >>>>>> The execution trace of H correctly deciding the halt status is shown in
> >>>>>> this paper:
> >>>>>>
> >>>>>> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
> >>>>>>
> >>>>>> When H(P,P) continues to be invoked with identical input this
> >>>>>> conclusively proves that it is invoked in infinitely nested simulation
> >>>>>> that can never reach the final state of [00000c50] (and thus halt)
> >>>>>> whether or not this simulation is aborted.
> >>>>>>
> >>>>>> Because the execution trace is so very obviously self-evidently correct
> >>>>>> all the calls to see the source code were ruse.
> >>>>>> --
> >>>>>> Copyright 2021 Pete Olcott
> >>>>>>
> >>>>>> Talent hits a target no one else can hit;
> >>>>>> Genius hits a target no one else can see.
> >>>>>> Arthur Schopenhauer
> >>>>>
> >>>>> By now, no one believes what you say.
> >>>> Which is no actual rebuttal what-so-ever.
> >>>> Prior to Pythagoras everyone knew that the Earth was flat.
> >>>> --
> >>>> Copyright 2021 Pete Olcott
> >>>>
> >>>> Talent hits a target no one else can hit;
> >>>> Genius hits a target no one else can see.
> >>>> Arthur Schopenhauer
> >>>
> >>> You are trying to evade your error again.
> >>> Where is the complete proof?
> >> You must read rather than ignore this paper.
> >> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
> >>> Anybody can use the the same code fragment of yours to prove the opposite of
> >>> what you claim. E.g. "It is more so obviously self-evidently correct that H cannot return (undecidable)".
> >>> The code fragment shows infinitely calls, isn't it? Where does H return (or reach a final state)?
> >> --
> >> Copyright 2021 Pete Olcott
> >>
> >> Talent hits a target no one else can hit;
> >> Genius hits a target no one else can see.
> >> Arthur Schopenhauer
> >
> > All shown to me is that you don't know what undecidability means.
> All you have shown is that you haven't bothered to read my paper yet.
> > You cannot evade the fate to provided a complete proof. Your code
> > fragment is at most partial (and trivial), says nothing to the point.
> > As said, this is not the first time, you always find reason not to show
> > your H. (because no such H ever existed).
> > Admit it to save our time.
> --
> Copyright 2021 Pete Olcott
>
> Talent hits a target no one else can hit;
> Genius hits a target no one else can see.
> Arthur Schopenhauer

What the differences do you expect? If I read it and say something you
don't like, you would give me (like other people) another irrelevant link to read.
All have shown so far (many years) is that you cannot answer to the long
requested asking to provide your complete H (because no such H ever existed).
Admit it to save our (life) time.

On 3/22/22 10:44 PM, olcott wrote:
> On 3/22/2022 9:37 PM, wij wrote:
>> On Wednesday, 23 March 2022 at 10:30:07 UTC+8, olcott wrote:
>>> On 3/22/2022 9:20 PM, wij wrote:
>>>> On Wednesday, 23 March 2022 at 01:33:25 UTC+8, olcott wrote:
>>>>> ...
>>>>>> 1. You don't have such H.
>>>>>> Where is the claimed H these years? (just talks)
>>>>>> 2. You don't even have a correct implement of the P above, neither.
>>>>>> Your version is wrong. the "H(P)" in P is difficult to implement.
>>>>>> (no one think you can do it right)
>>>>>
>>>>> I have already done this.
>>>>>
>>>>> // Simplified Linz Ĥ (Linz:1990:319)
>>>>> // Strachey(1965) CPL translated to C
>>>>> void P(u32 x)
>>>>> {
>>>>> if (H(x, x))HERE:
>>>>> goto HERE;
>>>>> }
>>>>>
>>>>> int main()
>>>>> {
>>>>> Output("Input_Halts = ", H((u32)P, (u32)P));
>>>>> }
>>>>>
>>>>>
>>>>> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
>>>>>
>>>>
>>>> If H does not exist, how can P exist?
>>>>
>>>> You have been talking about a non-existent H for many years.
>>> That H has been fully operational for many months.
>>> --
>>> Copyright 2021 Pete Olcott
>>>
>>> Talent hits a target no one else can hit;
>>> Genius hits a target no one else can see.
>>> Arthur Schopenhauer
>>
>> Nop, you lied since the dawn of time. There is never such H as claimed.
>> You are always talking about something does not exist.
>
> If my H is incorrect then an error could be found.

Has been, many times. You just stick your fingers in you ears and say I
cant hear you

>
> It is the case the my H does correctly determine that P never meets the
> Linz definition of a halting computation: reaches a final state.
>

Nope.

> If you understand the x86 language you can see by the provided execution
> trace that H is correct.
>

On 3/22/22 11:10 PM, olcott wrote:
> On 3/22/2022 10:01 PM, wij wrote:
>> On Wednesday, 23 March 2022 at 10:44:20 UTC+8, olcott wrote:
>>> On 3/22/2022 9:37 PM, wij wrote:
>>>> On Wednesday, 23 March 2022 at 10:30:07 UTC+8, olcott wrote:
>>>>> On 3/22/2022 9:20 PM, wij wrote:
>>>>>> On Wednesday, 23 March 2022 at 01:33:25 UTC+8, olcott wrote:
>>>>>>> ...
>>>>>>>> 1. You don't have such H.
>>>>>>>> Where is the claimed H these years? (just talks)
>>>>>>>> 2. You don't even have a correct implement of the P above, neither.
>>>>>>>> Your version is wrong. the "H(P)" in P is difficult to
>>>>>>>> implement. (no one think you can do it right)
>>>>>>>
>>>>>>> I have already done this.
>>>>>>>
>>>>>>> // Simplified Linz Ĥ (Linz:1990:319)
>>>>>>> // Strachey(1965) CPL translated to C
>>>>>>> void P(u32 x)
>>>>>>> {
>>>>>>> if (H(x, x))HERE:
>>>>>>> goto HERE;
>>>>>>> }
>>>>>>>
>>>>>>> int main()
>>>>>>> {
>>>>>>> Output("Input_Halts = ", H((u32)P, (u32)P));
>>>>>>> }
>>>>>>>
>>>>>>>
>>>>>>> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
>>>>>>>
>>>>>>
>>>>>> If H does not exist, how can P exist?
>>>>>>
>>>>>> You have been talking about a non-existent H for many years.
>>>>> That H has been fully operational for many months.
>>>>> --
>>>>> Copyright 2021 Pete Olcott
>>>>>
>>>>> Talent hits a target no one else can hit;
>>>>> Genius hits a target no one else can see.
>>>>> Arthur Schopenhauer
>>>>
>>>> Nop, you lied since the dawn of time. There is never such H as claimed.
>>>> You are always talking about something does not exist.
>>> If my H is incorrect then an error could be found.
>>
>> It does not exist !!!
>> You have indicated that your H is done 'manually'. (not algorithmically)
>
> My C/x86 H/P combination is fully operational software based on a very
> powerful x86 emulator.

And has PROVED that you are worng.

>
>>
>>> It is the case the my H does correctly determine that P never meets the
>>> Linz definition of a halting computation: reaches a final state.
>>>
>>> If you understand the x86 language you can see by the provided execution
>>> trace that H is correct.
>>> --
>>
>> And now, you provided it 'verbally'.
>> People had requested you to show your H many times, you always find
>> reason not  to,
>> even CHANGE your theory again and again.
>> Is it fair to call you a liar?
>
> The execution trace of H correctly deciding the halt status is shown in
> this paper:
>
> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
>

Which is full of logical errors and bad definitiosn as pointed out before.

>
> When H(P,P) continues to be invoked with identical input this
> conclusively proves that it is invoked in infinitely nested simulation
> that can never reach the final state of [00000c50] (and thus halt)
> whether or not this simulation is aborted.
>
> Because the execution trace is so very obviously self-evidently correct
> all the calls to see the source code were ruse.
>
>

And that same program has proved that P(P) halts:

On 4/27/21 12:55 AM, olcott wrote:
Message-ID: <Teudndbu59GVBBr9nZ2dnUU7-V2dnZ2d@giganews.com>
> void H_Hat(u32 P)
> {
> u32 Input_Halts = Halts(P, P);
> if (Input_Halts)
> HERE: goto HERE;
> }
>
>
> int main()
> {
> H_Hat((u32)H_Hat);
> }
>
>
> _H_Hat()
> [00000b98](01) 55 push ebp
> [00000b99](02) 8bec mov ebp,esp
>
[00000b9b](01) 51 push ecx
> [00000b9c](03) 8b4508 mov eax,[ebp+08]
> [00000b9f](01) 50 push eax
> [00000ba0](03) 8b4d08 mov ecx,[ebp+08]
> [00000ba3](01) 51 push ecx
> [00000ba4](05) e88ffdffff call 00000938
> [00000ba9](03) 83c408 add esp,+08
> [00000bac](03) 8945fc mov [ebp-04],eax
> [00000baf](04) 837dfc00 cmp dword [ebp-04],+00
> [00000bb3](02) 7402 jz 00000bb7
> [00000bb5](02) ebfe jmp 00000bb5
> [00000bb7](02) 8be5 mov esp,ebp
> [00000bb9](01) 5d pop ebp
> [00000bba](01) c3 ret
> Size in bytes:(0035) [00000bba]
>
> _main()
> [00000bc8](01) 55 push ebp
> [00000bc9](02) 8bec mov ebp,esp
> [00000bcb](05) 68980b0000 push 00000b98
> [00000bd0](05) e8c3ffffff call 00000b98
> [00000bd5](03) 83c404 add esp,+04
> [00000bd8](02) 33c0 xor eax,eax
> [00000bda](01) 5d pop ebp
> [00000bdb](01) c3 ret
> Size in bytes:(0020) [00000bdb]
>
> ===============================
> ...[00000bc8][001015d4][00000000](01) 55 push ebp
> ...[00000bc9][001015d4][00000000](02) 8bec mov ebp,esp
> ...[00000bcb][001015d0][00000b98](05) 68980b0000 push 00000b98
> ...[00000bd0][001015cc][00000bd5](05) e8c3ffffff call 00000b98
> ...[00000b98][001015c8][001015d4](01) 55 push ebp
> ...[00000b99][001015c8][001015d4](02) 8bec mov ebp,esp
> ...[00000b9b][001015c4][00000000](01) 51 push ecx
> ...[00000b9c][001015c4][00000000](03) 8b4508 mov eax,[ebp+08]
> ...[00000b9f][001015c0][00000b98](01) 50 push eax
> ...[00000ba0][001015c0][00000b98](03) 8b4d08 mov ecx,[ebp+08]
> ...[00000ba3][001015bc][00000b98](01) 51 push ecx
> ...[00000ba4][001015b8][00000ba9](05) e88ffdffff call 00000938
> Begin Local Halt Decider Simulation at Machine Address:b98
> ...[00000b98][00211674][00211678](01) 55 push ebp
> ...[00000b99][00211674][00211678](02) 8bec mov ebp,esp
> ...[00000b9b][00211670][00201644](01) 51 push ecx
> ...[00000b9c][00211670][00201644](03) 8b4508 mov eax,[ebp+08]
> ...[00000b9f][0021166c][00000b98](01) 50 push eax
> ...[00000ba0][0021166c][00000b98](03) 8b4d08 mov ecx,[ebp+08]
> ...[00000ba3][00211668][00000b98](01) 51 push ecx
> ...[00000ba4][00211664][00000ba9](05) e88ffdffff call 00000938
> ...[00000b98][0025c09c][0025c0a0](01) 55 push ebp
> ...[00000b99][0025c09c][0025c0a0](02) 8bec mov ebp,esp
> ...[00000b9b][0025c098][0024c06c](01) 51 push ecx
> ...[00000b9c][0025c098][0024c06c](03) 8b4508 mov eax,[ebp+08]
> ...[00000b9f][0025c094][00000b98](01) 50 push eax
> ...[00000ba0][0025c094][00000b98](03) 8b4d08 mov ecx,[ebp+08]
> ...[00000ba3][0025c090][00000b98](01) 51 push ecx
> ...[00000ba4][0025c08c][00000ba9](05) e88ffdffff call 00000938
> Local Halt Decider: Infinite Recursion Detected Simulation Stopped

Above decision was from the call the Halts inside H_Hat, deciding that
H_Hat(H_Hat) seems to be non-halting, it then returns that answer and is
processed below:

> ...[00000ba9][001015c4][00000000](03) 83c408 add esp,+08
> ...[00000bac][001015c4][00000000](03) 8945fc mov [ebp-04],eax
> ...[00000baf][001015c4][00000000](04) 837dfc00 cmp dword [ebp-04],+00
> ...[00000bb3][001015c4][00000000](02) 7402 jz 00000bb7
> ...[00000bb7][001015c8][001015d4](02) 8be5 mov esp,ebp
> ...[00000bb9][001015cc][00000bd5](01) 5d pop ebp
> ...[00000bba][001015d0][00000b98](01) c3 ret
> ...[00000bd5][001015d4][00000000](03) 83c404 add esp,+04
> ...[00000bd8][001015d4][00000000](02) 33c0 xor eax,eax
> ...[00000bda][001015d8][00100000](01) 5d pop ebp
> ...[00000bdb][001015dc][00000098](01) c3 ret

SEE IT HALTED!

> Number_of_User_Instructions(39)
> Number of Instructions Executed(26567)

olcott <NoOne@NoWhere.com> writes:

> On 3/22/2022 11:19 PM, wij wrote:

>> All shown to me is that you don't know what undecidability means.
>
> All you have shown is that you haven't bothered to read my paper yet.

You are funny! This from the man who has not even read Linz's proof
despite "working" on the problem for years. (I mean Linz's proper
proof, not the toy one presented as a historical curiosity.)

--
Ben.

On 3/23/2022 9:46 AM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 3/22/2022 11:19 PM, wij wrote:
>
>>> All shown to me is that you don't know what undecidability means.
>>
>> All you have shown is that you haven't bothered to read my paper yet.
>
> You are funny! This from the man who has not even read Linz's proof
> despite "working" on the problem for years. (I mean Linz's proper
> proof, not the toy one presented as a historical curiosity.)
>

As long as the simulated input to embedded_H would never reach its final
state then when embedded_H computes the mapping from this input to its
final reject state it is necessarily correct.

This has no correct rebuttal so to make it appear that you are providing
a rebuttal you change the subject and gullible fools never notice this
strawman error.

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer

On 3/23/22 11:08 AM, olcott wrote:
> On 3/23/2022 9:46 AM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 3/22/2022 11:19 PM, wij wrote:
>>
>>>> All shown to me is that you don't know what undecidability means.
>>>
>>> All you have shown is that you haven't bothered to read my paper yet.
>>
>> You are funny!  This from the man who has not even read Linz's proof
>> despite "working" on the problem for years.  (I mean Linz's proper
>> proof, not the toy one presented as a historical curiosity.)
>>
>
> As long as the simulated input to embedded_H would never reach its final
> state then when embedded_H computes the mapping from this input to its
> final reject state it is necessarily correct.
>
> This has no correct rebuttal so to make it appear that you are providing
> a rebuttal you change the subject and gullible fools never notice this
> strawman error.
>

Nope, since the DEFINITION of Halting is based on that Actual Behavior
of the Machine in question when given the input provided, and it has
been shown that this WILL reach a final state, if embedded_H -> Qn, that
pretty conclusively proves that H/embedded_H are wrong.

You keep on stating the CONJECTURE and claim it to be true, since we are
in a FORMAL logic system, before you can use a conjecture to prove
something, you first need to actually PROVE the conjecture, and not by
that hand wavy philosophical mumbo jubo with things lke 'The Meaning of
the Words', but with a FORMAL step by step proof based on the ACCEPTED
Axiom and definitions of the Logic Family plus those Theorems that have
been formally PROVED by that method.

YOU are the gullible fool that you have confused to believe your own
lies about what is actually true.