Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]


Groups > comp.software-eng > #2938 > unrolled thread

Re: Could H correctly decide that P never halts?

Started byolcott <NoOne@NoWhere.com>
First post2021-07-03 11:49 -0500
Last post2021-07-05 19:12 -0500
Articles 20 on this page of 30 — 2 participants

Back to article view | Back to comp.software-eng

This discussion starts older than the indexed window; earlier articles aren't shown. The article labeled Started by below is the oldest one visible, not the original post.


Contents

  Re: Could H correctly decide that P never halts? olcott <NoOne@NoWhere.com> - 2021-07-03 11:49 -0500
    Re: Could H correctly decide that P never halts? [ Why can H ignore its own behavior? ] olcott <NoOne@NoWhere.com> - 2021-07-03 14:08 -0500
      Re: Could H correctly decide that P never halts? [ Why can H ignore its own behavior? ](my thanks to Richard) olcott <NoOne@NoWhere.com> - 2021-07-03 15:37 -0500
        Re: Could H correctly decide that P never halts? [ Why can H ignore its own behavior? ](my thanks to Richard) olcott <NoOne@NoWhere.com> - 2021-07-03 17:20 -0500
          Re: Could H correctly decide that P never halts? [ Why can H ignore its own behavior? ](my thanks to Richard) Mr Flibble <flibble@reddwarf.jmc> - 2021-07-03 23:57 +0100
            Re: Could H correctly decide that P never halts? [ Why can H ignore its own behavior? ](my thanks to Richard) olcott <NoOne@NoWhere.com> - 2021-07-03 18:13 -0500
          Re: Could H correctly decide that P never halts? [ prerequisites to understanding me] olcott <NoOne@NoWhere.com> - 2021-07-03 18:34 -0500
            Re: Could H correctly decide that P never halts? [ prerequisites to understanding me] olcott <NoOne@NoWhere.com> - 2021-07-03 19:26 -0500
              Re: Could H correctly decide that P never halts? [ prerequisites to understanding me] olcott <NoOne@NoWhere.com> - 2021-07-03 21:22 -0500
                Re: Could H correctly decide that P never halts? [ prerequisites to understanding me] olcott <NoOne@NoWhere.com> - 2021-07-03 22:32 -0500
                  Re: Could H correctly decide that P never halts? [ prerequisites to understanding me] olcott <NoOne@NoWhere.com> - 2021-07-04 09:24 -0500
        Re: Could H correctly decide that P never halts? [ Why can H ignore its own behavior? ](my thanks to Richard) olcott <NoOne@NoWhere.com> - 2021-07-04 09:15 -0500
          Re: Could H correctly decide that P never halts? [ Why can H ignore its own behavior? ](my thanks to Richard) olcott <NoOne@NoWhere.com> - 2021-07-04 15:09 -0500
            Re: Could H correctly decide that P never halts? [ Why can H ignore its own behavior? ](my thanks to Richard) olcott <NoOne@NoWhere.com> - 2021-07-04 20:42 -0500
              Re: Could H correctly decide that P never halts? [ Why can H ignore its own behavior? ](my thanks to Richard) olcott <NoOne@NoWhere.com> - 2021-07-05 08:40 -0500
            Re: Could H correctly decide that P never halts? [ Why can H ignore its own behavior? ](my thanks to Richard) olcott <NoOne@NoWhere.com> - 2021-07-04 23:52 -0500
            Re: Could H correctly decide that P never halts? [ Why can H ignore its own behavior? ](my thanks to Richard) olcott <NoOne@NoWhere.com> - 2021-07-05 09:31 -0500
            Re: Could H correctly decide that P never halts? olcott <NoOne@NoWhere.com> - 2021-07-05 17:38 -0500
          Re: Could H correctly decide that P never halts? [ Why can H ignore its own behavior? ](my thanks to Richard) olcott <NoOne@NoWhere.com> - 2021-07-05 08:07 -0500
          Re: Could H correctly decide that P never halts? [ Why can H ignore its own behavior? ](my thanks to Richard) olcott <NoOne@NoWhere.com> - 2021-07-05 08:18 -0500
    Re: Could H correctly decide that P never halts? olcott <NoOne@NoWhere.com> - 2021-07-03 16:21 -0500
      Re: Could H correctly decide that P never halts? [ already agreed ] olcott <NoOne@NoWhere.com> - 2021-07-03 19:30 -0500
        Re: Could H correctly decide that P never halts? [ already agreed ] olcott <NoOne@NoWhere.com> - 2021-07-04 12:00 -0500
        Re: Could H correctly decide that P never halts? [ already agreed ] olcott <NoOne@NoWhere.com> - 2021-07-04 20:57 -0500
          Re: Could H correctly decide that P never halts? [ already agreed ] olcott <NoOne@NoWhere.com> - 2021-07-04 21:28 -0500
            Re: Could H correctly decide that P never halts? [ already agreed ] olcott <NoOne@NoWhere.com> - 2021-07-04 22:09 -0500
            Re: Could H correctly decide that P never halts? [ already agreed ] olcott <NoOne@NoWhere.com> - 2021-07-05 19:54 -0500
              Re: Could H correctly decide that P never halts? [ already agreed ] olcott <NoOne@NoWhere.com> - 2021-07-05 22:30 -0500
          Re: Could H correctly decide that P never halts? [ halting criteria ] olcott <NoOne@NoWhere.com> - 2021-07-05 08:26 -0500
          Re: Could H correctly decide that P never halts? [ Richard's excellent summation ] olcott <NoOne@NoWhere.com> - 2021-07-05 19:12 -0500

Page 1 of 2  [1] 2  Next page →


#2938 — Re: Could H correctly decide that P never halts?

Fromolcott <NoOne@NoWhere.com>
Date2021-07-03 11:49 -0500
SubjectRe: Could H correctly decide that P never halts?
Message-ID<INydnVdkv8OZCH39nZ2dnUU7-I_NnZ2d@giganews.com>
On 7/3/2021 11:25 AM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>>      void P(u32 x)
>>      {
>>        u32 Input_Halts = H(x, x);
>>        if (Input_Halts)
>>          HERE: goto HERE;
>>      }
> 
> For H(P,P) to be correct one of these must apply:
> 
>    H(P,P) == 0 and P(P) does not halt, or
>    H(P,P) != 0 and P(P) halts.
> 
> Neither is the case.
> 

Superficially it may seem that way until you realize (as you have 
already realized) that the halt criteria must be adapted for a 
simulating halt decider.

Because a simulating halt decider must always abort the simulation of 
every input that never halts its halt deciding criteria must be adapted.

Does the input halt on its input?
   must become
Does the input halt without having its simulation aborted?

This change is required because every input to a simulating halt decider 
either halts on its own or halts because its simulation has been aborted.

Halting problem undecidability and infinitely nested simulation

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


-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [next] | [standalone]


#2940 — Re: Could H correctly decide that P never halts? [ Why can H ignore its own behavior? ]

Fromolcott <NoOne@NoWhere.com>
Date2021-07-03 14:08 -0500
SubjectRe: Could H correctly decide that P never halts? [ Why can H ignore its own behavior? ]
Message-ID<vN2dnQt1A5wzKH39nZ2dnUU7-LvNnZ2d@giganews.com>
In reply to#2938
On 7/3/2021 1:17 PM, Richard Damon wrote:
> On 7/3/21 12:49 PM, olcott wrote:
>> On 7/3/2021 11:25 AM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>>       void P(u32 x)
>>>>       {
>>>>         u32 Input_Halts = H(x, x);
>>>>         if (Input_Halts)
>>>>           HERE: goto HERE;
>>>>       }
>>>
>>> For H(P,P) to be correct one of these must apply:
>>>
>>>     H(P,P) == 0 and P(P) does not halt, or
>>>     H(P,P) != 0 and P(P) halts.
>>>
>>> Neither is the case.
>>>
>>
>> Superficially it may seem that way until you realize (as you have
>> already realized) that the halt criteria must be adapted for a
>> simulating halt decider.
>>
> 
> WHY? The standard definition works perfectly fine? Does P(I) Halt or Not
> when it runs.
> 
>> Because a simulating halt decider must always abort the simulation of
>> every input that never halts its halt deciding criteria must be adapted.
> 
> But it must CORRECTLY halt. As has been shown, H incorrectly aborts the
> simulation of P because it doesn't take into account that this P WILL
> Halt because H does incorrectly halt its simulation.
>>
>> Does the input halt on its input?
>>    must become
>> Does the input halt without having its simulation aborted?
>>
>> This change is required because every input to a simulating halt decider
>> either halts on its own or halts because its simulation has been aborted.
> 
> But if it halts because the contained halt decider does abort its own
> simulation of a copy of P, then it IS a halting computation.
> 

This may be simply too difficult for you to understand.

When a simulating halt decider only simulates its input until it detects 
that its input exhibits non-halting behavior then

We can know that this simulating halt decider has no effect what-so-ever 
on the behavior of this input.

This also means that while a simulating halt decider is examining the 
behavior of its input it can safely ignore its own behavior.

When this simulating halt decider does detect an infinite execution 
behavior pattern then it can correctly stop simulating its input and 
report that its input does not halt.


>>
>> Halting problem undecidability and infinitely nested simulation
>>
>> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
>>
>>
>>
> 


-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#2941 — Re: Could H correctly decide that P never halts? [ Why can H ignore its own behavior? ](my thanks to Richard)

Fromolcott <NoOne@NoWhere.com>
Date2021-07-03 15:37 -0500
SubjectRe: Could H correctly decide that P never halts? [ Why can H ignore its own behavior? ](my thanks to Richard)
Message-ID<c-udnfvYE8oLV339nZ2dnUU7-e_NnZ2d@giganews.com>
In reply to#2940
On 7/3/2021 2:43 PM, Richard Damon wrote:
> On 7/3/21 3:08 PM, olcott wrote:
>> On 7/3/2021 1:17 PM, Richard Damon wrote:
>>> On 7/3/21 12:49 PM, olcott wrote:
>>>> On 7/3/2021 11:25 AM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>>        void P(u32 x)
>>>>>>        {
>>>>>>          u32 Input_Halts = H(x, x);
>>>>>>          if (Input_Halts)
>>>>>>            HERE: goto HERE;
>>>>>>        }
>>>>>
>>>>> For H(P,P) to be correct one of these must apply:
>>>>>
>>>>>      H(P,P) == 0 and P(P) does not halt, or
>>>>>      H(P,P) != 0 and P(P) halts.
>>>>>
>>>>> Neither is the case.
>>>>>
>>>>
>>>> Superficially it may seem that way until you realize (as you have
>>>> already realized) that the halt criteria must be adapted for a
>>>> simulating halt decider.
>>>>
>>>
>>> WHY? The standard definition works perfectly fine? Does P(I) Halt or Not
>>> when it runs.
>>>
>>>> Because a simulating halt decider must always abort the simulation of
>>>> every input that never halts its halt deciding criteria must be adapted.
>>>
>>> But it must CORRECTLY halt. As has been shown, H incorrectly aborts the
>>> simulation of P because it doesn't take into account that this P WILL
>>> Halt because H does incorrectly halt its simulation.
>>>>
>>>> Does the input halt on its input?
>>>>     must become
>>>> Does the input halt without having its simulation aborted?
>>>>
>>>> This change is required because every input to a simulating halt decider
>>>> either halts on its own or halts because its simulation has been
>>>> aborted.
>>>
>>> But if it halts because the contained halt decider does abort its own
>>> simulation of a copy of P, then it IS a halting computation.
>>>
>>
>> This may be simply too difficult for you to understand.
>>
>> When a simulating halt decider only simulates its input until it detects
>> that its input exhibits non-halting behavior then
>>
>> We can know that this simulating halt decider has no effect what-so-ever
>> on the behavior of this input.
>>
> 
> Right, but it DOES have an affect on its caller, which you neglect to
> take into account.
> 

If a simulating halt decider H ALWAYS merely simulates its input until 
it detects that its input matches an infinite execution behavior pattern 
then H can always ignore its own behavior when it is analyzing the halt 
status of its input.

Even though you have been very very annoying this last couple of message 
exchanges were very very helpful in that they forced me to make my 
explanations much much more clear. As a result of this I am very 
thankful for your reviews.

> Also, until its decision is actually PROVED correct, then the fact that
> it aborted its simulation does not by itself actually prove that the
> decision was correct and the input was actually non-halting.
> 

Of course it doesn't

>> This also means that while a simulating halt decider is examining the
>> behavior of its input it can safely ignore its own behavior.
> 
> It can ignore 'its own', but not other instances of itself. 

It can always ignore it own behavior and it can do this by screening out 
machine address ranges to be ignored. H ignores all of its own behavior 
and the behavior or every operating system function.

> If is sees a
> copy of itslef (even if the same exact source code executing at the same
> addresses, but in a different execution context). then because that
> decier CAN AND WILL affect the execution of the machine it is simulating
> (the caller of that copy) it MUST include its behavior.
> 

It is only the outer-most H that aborts the simulation of its input 
(only the outer H has seen the longest execution trace) and it only does 
this after its input has totally proven that it is never ever going to 
halt unless it is aborted.

> Fundamentally, you are missing the important Software Engineering
> concept of exectution context. The exact same code executing under
> different contexts needs to be considered as different identities.
> 

Not at all. It is a verifiable fact that every H only simulates its 
input until its input has proven beyond all possible doubt that it is 
never ever going to halt unless aborted by some H.

>>
>> When this simulating halt decider does detect an infinite execution
>> behavior pattern then it can correctly stop simulating its input and
>> report that its input does not halt.
>>
>>
> It has INCORRECTLY detected an infinite execution because it has failed
> to take into account the actions of the copy of H within its simulation.
> 

void P(u32 x)
{
   u32 Input_Halts = H(x, x);
   if (Input_Halts)
     HERE: goto HERE;
}

There are no copies. There are nested invocations that all share the 
same machine code in the same way that recursive invocations share the 
same machine code. Nested simulations are really nothing more than a 
slightly more complex case of recursive invocation.

> It is starting by ASSUMING that H doesn't abort its simulation. As soon
> as it decides that maybe it should abort its own simulation, it needs to

H only aborts its simulation after it has 100% perfect proof that it must.

> feed that change of condition back into its logic about what it has
> seen. Since it is contemplating aborting its own simulation, it needs to
> take into account that other copies might do the same. Failure to do so
> leads to faulting reasoning and wrong answers.
> 

As soon as the input to H meets the infinite recursion criteria H stops 
its simulation.



-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#2944 — Re: Could H correctly decide that P never halts? [ Why can H ignore its own behavior? ](my thanks to Richard)

Fromolcott <NoOne@NoWhere.com>
Date2021-07-03 17:20 -0500
SubjectRe: Could H correctly decide that P never halts? [ Why can H ignore its own behavior? ](my thanks to Richard)
Message-ID<4LqdnZ68Ev4qf339nZ2dnUU7-UHNnZ2d@giganews.com>
In reply to#2941
On 7/3/2021 4:58 PM, Richard Damon wrote:
> On 7/3/21 4:37 PM, olcott wrote:
>> On 7/3/2021 2:43 PM, Richard Damon wrote:
>>> On 7/3/21 3:08 PM, olcott wrote:
>>>> On 7/3/2021 1:17 PM, Richard Damon wrote:
>>>>> On 7/3/21 12:49 PM, olcott wrote:
>>>>>> On 7/3/2021 11:25 AM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>>         void P(u32 x)
>>>>>>>>         {
>>>>>>>>           u32 Input_Halts = H(x, x);
>>>>>>>>           if (Input_Halts)
>>>>>>>>             HERE: goto HERE;
>>>>>>>>         }
>>>>>>>
>>>>>>> For H(P,P) to be correct one of these must apply:
>>>>>>>
>>>>>>>       H(P,P) == 0 and P(P) does not halt, or
>>>>>>>       H(P,P) != 0 and P(P) halts.
>>>>>>>
>>>>>>> Neither is the case.
>>>>>>>
>>>>>>
>>>>>> Superficially it may seem that way until you realize (as you have
>>>>>> already realized) that the halt criteria must be adapted for a
>>>>>> simulating halt decider.
>>>>>>
>>>>>
>>>>> WHY? The standard definition works perfectly fine? Does P(I) Halt or
>>>>> Not
>>>>> when it runs.
>>>>>
>>>>>> Because a simulating halt decider must always abort the simulation of
>>>>>> every input that never halts its halt deciding criteria must be
>>>>>> adapted.
>>>>>
>>>>> But it must CORRECTLY halt. As has been shown, H incorrectly aborts the
>>>>> simulation of P because it doesn't take into account that this P WILL
>>>>> Halt because H does incorrectly halt its simulation.
>>>>>>
>>>>>> Does the input halt on its input?
>>>>>>      must become
>>>>>> Does the input halt without having its simulation aborted?
>>>>>>
>>>>>> This change is required because every input to a simulating halt
>>>>>> decider
>>>>>> either halts on its own or halts because its simulation has been
>>>>>> aborted.
>>>>>
>>>>> But if it halts because the contained halt decider does abort its own
>>>>> simulation of a copy of P, then it IS a halting computation.
>>>>>
>>>>
>>>> This may be simply too difficult for you to understand.
>>>>
>>>> When a simulating halt decider only simulates its input until it detects
>>>> that its input exhibits non-halting behavior then
>>>>
>>>> We can know that this simulating halt decider has no effect what-so-ever
>>>> on the behavior of this input.
>>>>
>>>
>>> Right, but it DOES have an affect on its caller, which you neglect to
>>> take into account.
>>>
>>
>> If a simulating halt decider H ALWAYS merely simulates its input until
>> it detects that its input matches an infinite execution behavior pattern
>> then H can always ignore its own behavior when it is analyzing the halt
>> status of its input.
> 
> No it can't. Because the fact that H does abort it simulation does
> affect the code that we simulated CALLING that H.
> 

No H ever aborts any P until after some P have proved beyond all 
possible doubt that it will never halt unless aborted. Until some P does 
prove this every H only acts as an x86 emulator and nothing more.




-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#2945 — Re: Could H correctly decide that P never halts? [ Why can H ignore its own behavior? ](my thanks to Richard)

FromMr Flibble <flibble@reddwarf.jmc>
Date2021-07-03 23:57 +0100
SubjectRe: Could H correctly decide that P never halts? [ Why can H ignore its own behavior? ](my thanks to Richard)
Message-ID<20210703235753.0000687f@reddwarf.jmc>
In reply to#2944
On Sat, 3 Jul 2021 17:20:39 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 7/3/2021 4:58 PM, Richard Damon wrote:
> > On 7/3/21 4:37 PM, olcott wrote:  
> >> On 7/3/2021 2:43 PM, Richard Damon wrote:  
> >>> On 7/3/21 3:08 PM, olcott wrote:  
> >>>> On 7/3/2021 1:17 PM, Richard Damon wrote:  
> >>>>> On 7/3/21 12:49 PM, olcott wrote:  
> >>>>>> On 7/3/2021 11:25 AM, Ben Bacarisse wrote:  
> >>>>>>> olcott <NoOne@NoWhere.com> writes:
> >>>>>>>  
> >>>>>>>>         void P(u32 x)
> >>>>>>>>         {
> >>>>>>>>           u32 Input_Halts = H(x, x);
> >>>>>>>>           if (Input_Halts)
> >>>>>>>>             HERE: goto HERE;
> >>>>>>>>         }  
> >>>>>>>
> >>>>>>> For H(P,P) to be correct one of these must apply:
> >>>>>>>
> >>>>>>>       H(P,P) == 0 and P(P) does not halt, or
> >>>>>>>       H(P,P) != 0 and P(P) halts.
> >>>>>>>
> >>>>>>> Neither is the case.
> >>>>>>>  
> >>>>>>
> >>>>>> Superficially it may seem that way until you realize (as you
> >>>>>> have already realized) that the halt criteria must be adapted
> >>>>>> for a simulating halt decider.
> >>>>>>  
> >>>>>
> >>>>> WHY? The standard definition works perfectly fine? Does P(I)
> >>>>> Halt or Not
> >>>>> when it runs.
> >>>>>  
> >>>>>> Because a simulating halt decider must always abort the
> >>>>>> simulation of every input that never halts its halt deciding
> >>>>>> criteria must be adapted.  
> >>>>>
> >>>>> But it must CORRECTLY halt. As has been shown, H incorrectly
> >>>>> aborts the simulation of P because it doesn't take into account
> >>>>> that this P WILL Halt because H does incorrectly halt its
> >>>>> simulation.  
> >>>>>>
> >>>>>> Does the input halt on its input?
> >>>>>>      must become
> >>>>>> Does the input halt without having its simulation aborted?
> >>>>>>
> >>>>>> This change is required because every input to a simulating
> >>>>>> halt decider
> >>>>>> either halts on its own or halts because its simulation has
> >>>>>> been aborted.  
> >>>>>
> >>>>> But if it halts because the contained halt decider does abort
> >>>>> its own simulation of a copy of P, then it IS a halting
> >>>>> computation. 
> >>>>
> >>>> This may be simply too difficult for you to understand.
> >>>>
> >>>> When a simulating halt decider only simulates its input until it
> >>>> detects that its input exhibits non-halting behavior then
> >>>>
> >>>> We can know that this simulating halt decider has no effect
> >>>> what-so-ever on the behavior of this input.
> >>>>  
> >>>
> >>> Right, but it DOES have an affect on its caller, which you
> >>> neglect to take into account.
> >>>  
> >>
> >> If a simulating halt decider H ALWAYS merely simulates its input
> >> until it detects that its input matches an infinite execution
> >> behavior pattern then H can always ignore its own behavior when it
> >> is analyzing the halt status of its input.  
> > 
> > No it can't. Because the fact that H does abort it simulation does
> > affect the code that we simulated CALLING that H.
> >   
> 
> No H ever aborts any P until after some P have proved beyond all 
> possible doubt that it will never halt unless aborted. Until some P
> does prove this every H only acts as an x86 emulator and nothing more.

But you can only decide it will never halt for uninteresting trivial
cases: until you decider can handle an arbitrary algorithm predicated
on arbitrary program input you've got nothing.

/Flibble

[toc] | [prev] | [next] | [standalone]


#2946 — Re: Could H correctly decide that P never halts? [ Why can H ignore its own behavior? ](my thanks to Richard)

Fromolcott <NoOne@NoWhere.com>
Date2021-07-03 18:13 -0500
SubjectRe: Could H correctly decide that P never halts? [ Why can H ignore its own behavior? ](my thanks to Richard)
Message-ID<sK-dnd5fZ4Njc339nZ2dnUU7-WHNnZ2d@giganews.com>
In reply to#2945
On 7/3/2021 5:57 PM, Mr Flibble wrote:
> On Sat, 3 Jul 2021 17:20:39 -0500
> olcott <NoOne@NoWhere.com> wrote:
> 
>> On 7/3/2021 4:58 PM, Richard Damon wrote:
>>> On 7/3/21 4:37 PM, olcott wrote:
>>>> On 7/3/2021 2:43 PM, Richard Damon wrote:
>>>>> On 7/3/21 3:08 PM, olcott wrote:
>>>>>> On 7/3/2021 1:17 PM, Richard Damon wrote:
>>>>>>> On 7/3/21 12:49 PM, olcott wrote:
>>>>>>>> On 7/3/2021 11:25 AM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>   
>>>>>>>>>>          void P(u32 x)
>>>>>>>>>>          {
>>>>>>>>>>            u32 Input_Halts = H(x, x);
>>>>>>>>>>            if (Input_Halts)
>>>>>>>>>>              HERE: goto HERE;
>>>>>>>>>>          }
>>>>>>>>>
>>>>>>>>> For H(P,P) to be correct one of these must apply:
>>>>>>>>>
>>>>>>>>>        H(P,P) == 0 and P(P) does not halt, or
>>>>>>>>>        H(P,P) != 0 and P(P) halts.
>>>>>>>>>
>>>>>>>>> Neither is the case.
>>>>>>>>>   
>>>>>>>>
>>>>>>>> Superficially it may seem that way until you realize (as you
>>>>>>>> have already realized) that the halt criteria must be adapted
>>>>>>>> for a simulating halt decider.
>>>>>>>>   
>>>>>>>
>>>>>>> WHY? The standard definition works perfectly fine? Does P(I)
>>>>>>> Halt or Not
>>>>>>> when it runs.
>>>>>>>   
>>>>>>>> Because a simulating halt decider must always abort the
>>>>>>>> simulation of every input that never halts its halt deciding
>>>>>>>> criteria must be adapted.
>>>>>>>
>>>>>>> But it must CORRECTLY halt. As has been shown, H incorrectly
>>>>>>> aborts the simulation of P because it doesn't take into account
>>>>>>> that this P WILL Halt because H does incorrectly halt its
>>>>>>> simulation.
>>>>>>>>
>>>>>>>> Does the input halt on its input?
>>>>>>>>       must become
>>>>>>>> Does the input halt without having its simulation aborted?
>>>>>>>>
>>>>>>>> This change is required because every input to a simulating
>>>>>>>> halt decider
>>>>>>>> either halts on its own or halts because its simulation has
>>>>>>>> been aborted.
>>>>>>>
>>>>>>> But if it halts because the contained halt decider does abort
>>>>>>> its own simulation of a copy of P, then it IS a halting
>>>>>>> computation.
>>>>>>
>>>>>> This may be simply too difficult for you to understand.
>>>>>>
>>>>>> When a simulating halt decider only simulates its input until it
>>>>>> detects that its input exhibits non-halting behavior then
>>>>>>
>>>>>> We can know that this simulating halt decider has no effect
>>>>>> what-so-ever on the behavior of this input.
>>>>>>   
>>>>>
>>>>> Right, but it DOES have an affect on its caller, which you
>>>>> neglect to take into account.
>>>>>   
>>>>
>>>> If a simulating halt decider H ALWAYS merely simulates its input
>>>> until it detects that its input matches an infinite execution
>>>> behavior pattern then H can always ignore its own behavior when it
>>>> is analyzing the halt status of its input.
>>>
>>> No it can't. Because the fact that H does abort it simulation does
>>> affect the code that we simulated CALLING that H.
>>>    
>>
>> No H ever aborts any P until after some P have proved beyond all
>> possible doubt that it will never halt unless aborted. Until some P
>> does prove this every H only acts as an x86 emulator and nothing more.
> 
> But you can only decide it will never halt for uninteresting trivial
> cases: until you decider can handle an arbitrary algorithm predicated
> on arbitrary program input you've got nothing.
> 
> /Flibble
> 
> 

The same input that you are calling "trivial" is the same input that all 
the conventional halting problem proofs call "impossible".

// Simplified Linz Ĥ (Linz:1990:319)
void P(u32 x)
{
   u32 Input_Halts = H(x, x);
   if (Input_Halts)
     HERE: goto HERE;
}

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

Halting problem undecidability and infinitely nested simulation

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


-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#2947 — Re: Could H correctly decide that P never halts? [ prerequisites to understanding me]

Fromolcott <NoOne@NoWhere.com>
Date2021-07-03 18:34 -0500
SubjectRe: Could H correctly decide that P never halts? [ prerequisites to understanding me]
Message-ID<jcydnVpdAp5rbn39nZ2dnUU7-S_NnZ2d@giganews.com>
In reply to#2944
On 7/3/2021 6:04 PM, Richard Damon wrote:
> On 7/3/21 6:20 PM, olcott wrote:
>> On 7/3/2021 4:58 PM, Richard Damon wrote:
>>> On 7/3/21 4:37 PM, olcott wrote:
> 
>>>> If a simulating halt decider H ALWAYS merely simulates its input until
>>>> it detects that its input matches an infinite execution behavior pattern
>>>> then H can always ignore its own behavior when it is analyzing the halt
>>>> status of its input.
>>>
>>> No it can't. Because the fact that H does abort it simulation does
>>> affect the code that we simulated CALLING that H.
>>>
>>
>> No H ever aborts any P until after some P have proved beyond all
>> possible doubt that it will never halt unless aborted. Until some P does
>> prove this every H only acts as an x86 emulator and nothing more.
>>
>>
> 
> You CLAIM this, but you actual have no proof that it is.
> 
> Your proof shows that unless SOME H abort the chain, not THIS H abort
> the chain.
> 

As long as every H only acts as a pure x86 emulator until some P 
exhibits behavior that would never halt unless aborted by some H then 
entirely on the basis of the meaning of these words when this H (that 
sees the never halting behavior) aborts that P it correctly decides that 
P does not halt.

I think that you are smart enough to verify that the above reasoning is 
correct.

You may not be technically proficient enough to verify that the above 
reasoning is indeed the case.

If one is an expert at both C programming and x86 assembly language 
programming then the above reasoning can be verified as what is actually 
occurring.

It is very easy to see by the execution trace of P compared to the 
assembly language source-code of P that H is perfectly simulating P.

Halting problem undecidability and infinitely nested simulation

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



-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#2948 — Re: Could H correctly decide that P never halts? [ prerequisites to understanding me]

Fromolcott <NoOne@NoWhere.com>
Date2021-07-03 19:26 -0500
SubjectRe: Could H correctly decide that P never halts? [ prerequisites to understanding me]
Message-ID<fKWdnXp_S-GEnXz9nZ2dnUU7-QPNnZ2d@giganews.com>
In reply to#2947
On 7/3/2021 7:06 PM, Richard Damon wrote:
> On 7/3/21 7:34 PM, olcott wrote:
>> On 7/3/2021 6:04 PM, Richard Damon wrote:
>>> On 7/3/21 6:20 PM, olcott wrote:
>>>> On 7/3/2021 4:58 PM, Richard Damon wrote:
>>>>> On 7/3/21 4:37 PM, olcott wrote:
>>>
>>>>>> If a simulating halt decider H ALWAYS merely simulates its input until
>>>>>> it detects that its input matches an infinite execution behavior
>>>>>> pattern
>>>>>> then H can always ignore its own behavior when it is analyzing the
>>>>>> halt
>>>>>> status of its input.
>>>>>
>>>>> No it can't. Because the fact that H does abort it simulation does
>>>>> affect the code that we simulated CALLING that H.
>>>>>
>>>>
>>>> No H ever aborts any P until after some P have proved beyond all
>>>> possible doubt that it will never halt unless aborted. Until some P does
>>>> prove this every H only acts as an x86 emulator and nothing more.
>>>>
>>>>
>>>
>>> You CLAIM this, but you actual have no proof that it is.
>>>
>>> Your proof shows that unless SOME H abort the chain, not THIS H abort
>>> the chain.
>>>
>>
>> As long as every H only acts as a pure x86 emulator until some P
>> exhibits behavior that would never halt unless aborted by some H then
>> entirely on the basis of the meaning of these words when this H (that
>> sees the never halting behavior) aborts that P it correctly decides that
>> P does not halt.
> 
> That is A FALSE statement by the meaning of the words. SO THERE.
> 
> The only instance of H that you can possibly make that claim for is the
> top level H which isn't called by P. Any H that is called by a P because
> its actions DO affect the behavior of that P that calles it, MUST have
> that behavior looked at as it affect the P that the top level H is
> looking at.
> 

I went too fast for you. I will break it down to simpler steps.

No H has any effect on any computation what-so-ever until some H 
determines that some P would never halt unless aborted.

> PURE MEANING OF THE WORDS.
> 
> PROVE OTHERWISE.
> 
> Show ANYONE else with a reputation who agrees with your statement.
> 
> You confuse the different instances of H and P, and thus come to wrong
> conclusions.
> 
>>
>> I think that you are smart enough to verify that the above reasoning is
>> correct.
>>
>> You may not be technically proficient enough to verify that the above
>> reasoning is indeed the case.
> 
> YOU are the one not technically proficient enough to understand.
> 
> You show ZERO understanding of what a Turing Machine actually is.
> You show ZERO understanding of what Computation Theory is about.
> You show minimal understanding of Software Engineering principles.
> 
>>
>> If one is an expert at both C programming and x86 assembly language
>> programming then the above reasoning can be verified as what is actually
>> occurring.
> 
> Being one, I say BUNK. You statement is wrong.
> 
>>
>> It is very easy to see by the execution trace of P compared to the
>> assembly language source-code of P that H is perfectly simulating P.
> 
> You mean you INCORRECT traces?
> 
> FAIL.
> 
>>
>> Halting problem undecidability and infinitely nested simulation
>>
>> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
>>
>>
>>
> 


-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#2950 — Re: Could H correctly decide that P never halts? [ prerequisites to understanding me]

Fromolcott <NoOne@NoWhere.com>
Date2021-07-03 21:22 -0500
SubjectRe: Could H correctly decide that P never halts? [ prerequisites to understanding me]
Message-ID<CNSdnZ-wXJXuhnz9nZ2dnUU7-YnNnZ2d@giganews.com>
In reply to#2948
On 7/3/2021 9:13 PM, Richard Damon wrote:
> On 7/3/21 9:41 PM, olcott wrote:
>> On 7/3/2021 8:21 PM, Richard Damon wrote:
>>> On 7/3/21 8:26 PM, olcott wrote:
>>>> On 7/3/2021 7:06 PM, Richard Damon wrote:
>>>>> On 7/3/21 7:34 PM, olcott wrote:
>>>>>> On 7/3/2021 6:04 PM, Richard Damon wrote:
>>>>>>> On 7/3/21 6:20 PM, olcott wrote:
>>>>>>>> On 7/3/2021 4:58 PM, Richard Damon wrote:
>>>>>>>>> On 7/3/21 4:37 PM, olcott wrote:
>>>>>>>
>>>>>>>>>> If a simulating halt decider H ALWAYS merely simulates its input
>>>>>>>>>> until
>>>>>>>>>> it detects that its input matches an infinite execution behavior
>>>>>>>>>> pattern
>>>>>>>>>> then H can always ignore its own behavior when it is analyzing the
>>>>>>>>>> halt
>>>>>>>>>> status of its input.
>>>>>>>>>
>>>>>>>>> No it can't. Because the fact that H does abort it simulation does
>>>>>>>>> affect the code that we simulated CALLING that H.
>>>>>>>>>
>>>>>>>>
>>>>>>>> No H ever aborts any P until after some P have proved beyond all
>>>>>>>> possible doubt that it will never halt unless aborted. Until some P
>>>>>>>> does
>>>>>>>> prove this every H only acts as an x86 emulator and nothing more.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> You CLAIM this, but you actual have no proof that it is.
>>>>>>>
>>>>>>> Your proof shows that unless SOME H abort the chain, not THIS H abort
>>>>>>> the chain.
>>>>>>>
>>>>>>
>>>>>> As long as every H only acts as a pure x86 emulator until some P
>>>>>> exhibits behavior that would never halt unless aborted by some H then
>>>>>> entirely on the basis of the meaning of these words when this H (that
>>>>>> sees the never halting behavior) aborts that P it correctly decides
>>>>>> that
>>>>>> P does not halt.
>>>>>
>>>>> That is A FALSE statement by the meaning of the words. SO THERE.
>>>>>
>>>>> The only instance of H that you can possibly make that claim for is the
>>>>> top level H which isn't called by P. Any H that is called by a P
>>>>> because
>>>>> its actions DO affect the behavior of that P that calles it, MUST have
>>>>> that behavior looked at as it affect the P that the top level H is
>>>>> looking at.
>>>>>
>>>>
>>>> I went too fast for you. I will break it down to simpler steps.
>>>>
>>>> No H has any effect on any computation what-so-ever until some H
>>>> determines that some P would never halt unless aborted.
>>>
>>> So, the fact that some H has reached its programmed decision to abort
>>
>> Is 100% totally irrelevant to what I just said.
>> I am ONLY talking about the execution before this point.
>>
> 
> If the actual behavior of the system is 100% totally irrelevent to what
> you are saying then THAT'S your problem.
No the problem is that your attention span is very very short so I 
cannot possibly expect you to be able to follow more than one single 
point at a time.

Do you understand that H cannot possibly have any effect what-so-ever on 
the behavior of P until after the behavior of P proves that it will 
never halt unless it is aborted?

We cannot move to the next point until AFTER you understand this point.
It usually takes you at least a month to understand one single point 
because your mind keeps scattering over many other points not directly 
related to this one single point.

I took it as dishonestly it might actually be a neurological abnormality.

-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#2951 — Re: Could H correctly decide that P never halts? [ prerequisites to understanding me]

Fromolcott <NoOne@NoWhere.com>
Date2021-07-03 22:32 -0500
SubjectRe: Could H correctly decide that P never halts? [ prerequisites to understanding me]
Message-ID<4a2dnQsWCodftnz9nZ2dnUU7-XfNnZ2d@giganews.com>
In reply to#2950
On 7/3/2021 10:24 PM, Richard Damon wrote:
> On 7/3/21 10:22 PM, olcott wrote:
>> On 7/3/2021 9:13 PM, Richard Damon wrote:
>>> On 7/3/21 9:41 PM, olcott wrote:
>>>> On 7/3/2021 8:21 PM, Richard Damon wrote:
>>>>> On 7/3/21 8:26 PM, olcott wrote:
>>>>>> On 7/3/2021 7:06 PM, Richard Damon wrote:
>>>>>>> On 7/3/21 7:34 PM, olcott wrote:
>>>>>>>> On 7/3/2021 6:04 PM, Richard Damon wrote:
>>>>>>>>> On 7/3/21 6:20 PM, olcott wrote:
>>>>>>>>>> On 7/3/2021 4:58 PM, Richard Damon wrote:
>>>>>>>>>>> On 7/3/21 4:37 PM, olcott wrote:
>>>>>>>>>
>>>>>>>>>>>> If a simulating halt decider H ALWAYS merely simulates its input
>>>>>>>>>>>> until
>>>>>>>>>>>> it detects that its input matches an infinite execution behavior
>>>>>>>>>>>> pattern
>>>>>>>>>>>> then H can always ignore its own behavior when it is
>>>>>>>>>>>> analyzing the
>>>>>>>>>>>> halt
>>>>>>>>>>>> status of its input.
>>>>>>>>>>>
>>>>>>>>>>> No it can't. Because the fact that H does abort it simulation
>>>>>>>>>>> does
>>>>>>>>>>> affect the code that we simulated CALLING that H.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> No H ever aborts any P until after some P have proved beyond all
>>>>>>>>>> possible doubt that it will never halt unless aborted. Until
>>>>>>>>>> some P
>>>>>>>>>> does
>>>>>>>>>> prove this every H only acts as an x86 emulator and nothing more.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> You CLAIM this, but you actual have no proof that it is.
>>>>>>>>>
>>>>>>>>> Your proof shows that unless SOME H abort the chain, not THIS H
>>>>>>>>> abort
>>>>>>>>> the chain.
>>>>>>>>>
>>>>>>>>
>>>>>>>> As long as every H only acts as a pure x86 emulator until some P
>>>>>>>> exhibits behavior that would never halt unless aborted by some H
>>>>>>>> then
>>>>>>>> entirely on the basis of the meaning of these words when this H
>>>>>>>> (that
>>>>>>>> sees the never halting behavior) aborts that P it correctly decides
>>>>>>>> that
>>>>>>>> P does not halt.
>>>>>>>
>>>>>>> That is A FALSE statement by the meaning of the words. SO THERE.
>>>>>>>
>>>>>>> The only instance of H that you can possibly make that claim for
>>>>>>> is the
>>>>>>> top level H which isn't called by P. Any H that is called by a P
>>>>>>> because
>>>>>>> its actions DO affect the behavior of that P that calles it, MUST
>>>>>>> have
>>>>>>> that behavior looked at as it affect the P that the top level H is
>>>>>>> looking at.
>>>>>>>
>>>>>>
>>>>>> I went too fast for you. I will break it down to simpler steps.
>>>>>>
>>>>>> No H has any effect on any computation what-so-ever until some H
>>>>>> determines that some P would never halt unless aborted.
>>>>>
>>>>> So, the fact that some H has reached its programmed decision to abort
>>>>
>>>> Is 100% totally irrelevant to what I just said.
>>>> I am ONLY talking about the execution before this point.
>>>>
>>>
>>> If the actual behavior of the system is 100% totally irrelevent to what
>>> you are saying then THAT'S your problem.
>> No the problem is that your attention span is very very short so I
>> cannot possibly expect you to be able to follow more than one single
>> point at a time.
> 
> Maybe my 'problem' is that I see to well and won't let a falsehood go
> past me. Your 'Proof' never gets off the ground, because you insist on
> alwasys starting with false premises that are 'close' to truths, and I
> shut you down before you can try to hide that rotten root.
> 
>>
>> Do you understand that H cannot possibly have any effect what-so-ever on
>> the behavior of P until after the behavior of P proves that it will
>> never halt unless it is aborted?
> 
> But since H will have an effect on the behavior of the calling P after
> it decides, that effect needs to be considered in 'proving' what it will
> do. 

Not really not at all. P has already proved that it will never halt 
unless H aborts it. Once P has done this then this proves that the not 
halting decision of H is necessarily correct.



-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#2953 — Re: Could H correctly decide that P never halts? [ prerequisites to understanding me]

Fromolcott <NoOne@NoWhere.com>
Date2021-07-04 09:24 -0500
SubjectRe: Could H correctly decide that P never halts? [ prerequisites to understanding me]
Message-ID<gPudnV6zDM0oWXz9nZ2dnUU7-RHNnZ2d@giganews.com>
In reply to#2951
On 7/4/2021 5:40 AM, Richard Damon wrote:
> On 7/3/21 11:32 PM, olcott wrote:
>> On 7/3/2021 10:24 PM, Richard Damon wrote:
> 
>>> But since H will have an effect on the behavior of the calling P after
>>> it decides, that effect needs to be considered in 'proving' what it will
>>> do.
>>
>> Not really not at all. P has already proved that it will never halt
>> unless H aborts it. Once P has done this then this proves that the not
>> halting decision of H is necessarily correct.
>>
> 
> But H HASN'T Actually done that because H makes the same mistake that
> you are doing that it forgets to consider that after it makes the
> decision and abort the simulation and return that answer, that in doing
> so it breaks the conditions that it made its proof.
> 

On 5/11/2021 11:10 AM, Ben Bacarisse wrote:
 > olcott <NoOne@NoWhere.com> writes:
 >
 >> Truism:
 >> Every simulation that would never stop unless Halts() stops
 >> it at some point specifies infinite execution.
 >
 > Any algorithm that implements this truism is, of course, a halting
 > decider.

Every computation that halts on its own without having to be aborted by 
the halt decider is a halting computation.

Every computation that never halts unless the halt decider aborted it is 
a non-halting computation.

Because a simulating halt decider must always abort the simulation of 
every input that never halts its halt deciding criteria must be adapted: 
*Does the input halt on its input?*   must become:
*Does the input halt without having its simulation aborted?*

This change is required because every input to a simulating halt decider 
either halts on its own or halts because its simulation has been aborted.




-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#2952 — Re: Could H correctly decide that P never halts? [ Why can H ignore its own behavior? ](my thanks to Richard)

Fromolcott <NoOne@NoWhere.com>
Date2021-07-04 09:15 -0500
SubjectRe: Could H correctly decide that P never halts? [ Why can H ignore its own behavior? ](my thanks to Richard)
Message-ID<sI-dnV3pkoUWX3z9nZ2dnUU7-bHNnZ2d@giganews.com>
In reply to#2941
On 7/4/2021 1:50 AM, André G. Isaak wrote:
> On 2021-07-03 22:18, olcott wrote:
>> On 7/3/2021 11:14 PM, André G. Isaak wrote:
>>> On 2021-07-03 19:38, olcott wrote:
>>>> On 7/3/2021 8:14 PM, André G. Isaak wrote:
>>>>> On 2021-07-03 14:37, olcott wrote:
>>>>>
>>>>>> It can always ignore it own behavior and it can do this by 
>>>>>> screening out machine address ranges to be ignored. H ignores all 
>>>>>> of its own behavior and the behavior or every operating system 
>>>>>> function.
>>>>>
>>>>> And in what universe does it make sense to simply ignore operating 
>>>>> system functions? 
>>>>
>>>> When making a halt deciding function it only makes sense to keep 
>>>> track of those aspects of computations that can cause the input to 
>>>> halt.
>>>
>>> And what on earth would lead you to believe that a system call could 
>>> have no impact on halting?
>>>
>>> (You conveniently skipped the example I gave.)
>>>
>>> André
>>>
>>
>> I am the only author of the entire x86utm operating system and all of 
>> its functions.
> 
> And we're just supposed to take your word for it that these can 
> legitimately be ignored?
> 
> Given that you've claimed that the instance of H called from within P 
> doesn't affect halting when it clearly does, your word isn't going to 
> carry much weight here.
> 

No instance of any H has any effect on any P until some P proves that it 
will never halt unless aborted. This has always been able to be directly 
verified by the assembly language execution trace of P relative to its 
assembly language source code.

This has been available posted directly in this forum since
On 3/14/2021 12:46 PM, olcott wrote:

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

> If it really were the case that these things didn't have any affect on 
> halting, then it would also be perfectly fine for your halt decider to 
> *not* skip this code in its analysis, and that would avoid objections 

Most importantly you can easily verify for yourself that P is accurately 
simulated by comparing its x86 source code to its x86 execution trace.

That no one has bothered to do this since March 14 would seem to 
indicate that no one here knows assembly language besides me.

I have proven that H has no effect on its input since March 13 and the 
16 lines of execution trace of the input proved to be totally 
overwhelming for everyone here. Adding 26,000 lines of more code would 
not help.

> along these lines. But if you did that you'd see that your assessment is 
> wrong.
> 
> André
> 


-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#2955 — Re: Could H correctly decide that P never halts? [ Why can H ignore its own behavior? ](my thanks to Richard)

Fromolcott <NoOne@NoWhere.com>
Date2021-07-04 15:09 -0500
SubjectRe: Could H correctly decide that P never halts? [ Why can H ignore its own behavior? ](my thanks to Richard)
Message-ID<8q-dncvsqrvtiH_9nZ2dnUU7-VvNnZ2d@giganews.com>
In reply to#2952
On 7/4/2021 2:00 PM, André G. Isaak wrote:
> On 2021-07-04 12:24, Malcolm McLean wrote:
> 
>> The execution trace showed two calls to the "halts" subroutine.
>> However it was stated that "halts" is a simulating decider. Therefore we
>> have one call to halts. It then emulates  another call to halts. But the
>> second call to "halts" shouldn't appear on the execution trace. It's 
>> emulated.
>>
>> So exactly what the decider is doing remains a bit opaque.
> 
> I've tried to get Olcott to clarify exactly what he means by 
> 'emulate'/'simulate' but to no avail. I'm fairly sure he doesn't mean 
> what the rest of the world means, but I still am unclear about what he 
> actually means.
> 
> André
> 

Sure everyone knows that an x86 emulator can be anything from a vanilla 
milkshake machine to a dump truck.  What I mean by x86 emulator is 
software that executes x86 machine language as if this software virtual 
machine was an actual x86 processor.

-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#2956 — Re: Could H correctly decide that P never halts? [ Why can H ignore its own behavior? ](my thanks to Richard)

Fromolcott <NoOne@NoWhere.com>
Date2021-07-04 20:42 -0500
SubjectRe: Could H correctly decide that P never halts? [ Why can H ignore its own behavior? ](my thanks to Richard)
Message-ID<K-mdnTaiYdQV_n_9nZ2dnUU7-fXNnZ2d@giganews.com>
In reply to#2955
On 7/4/2021 8:03 PM, dklei...@gmail.com wrote:
> On Sunday, July 4, 2021 at 1:55:27 PM UTC-7, André G. Isaak wrote:
>> On 2021-07-04 14:09, olcott wrote:
>>> On 7/4/2021 2:00 PM, André G. Isaak wrote:
>>>> On 2021-07-04 12:24, Malcolm McLean wrote:
>>>>
>>>>> The execution trace showed two calls to the "halts" subroutine.
>>>>> However it was stated that "halts" is a simulating decider. Therefore we
>>>>> have one call to halts. It then emulates another call to halts. But the
>>>>> second call to "halts" shouldn't appear on the execution trace. It's
>>>>> emulated.
>>>>>
>>>>> So exactly what the decider is doing remains a bit opaque.
>>>>
>>>> I've tried to get Olcott to clarify exactly what he means by
>>>> 'emulate'/'simulate' but to no avail. I'm fairly sure he doesn't mean
>>>> what the rest of the world means, but I still am unclear about what he
>>>> actually means.
>>>>
>>>> André
>>>>
>>>
>>> Sure everyone knows that an x86 emulator can be anything from a vanilla
>>> milkshake machine to a dump truck. What I mean by x86 emulator is
>>> software that executes x86 machine language as if this software virtual
>>> machine was an actual x86 processor.
>> The problem is that you keep talking about 'nested simulations' but
>> there's absolutely nothing in your code or your traces to suggest more
>> than a single level of emulation is involved.
>>
>> If your H *emulates* P, it should not contain a call to P. It should
>> contain a call to some function EMULATE with some description of P
>> (either a file or a memory location) as an *argument* to that function.
>> If that P includes an H which also emulates its input, there should be a
>> second call to EMULATE, meaning we should have one instance of the
>> emulator running on the actual hardware, and a second instance of the
>> emulator being interpreted by the first emulator rather than being run
>> on the actual hardware, and with a second instance of P being
>> interpreted by that emulated emulator rather than either the hardware or
>> the emulator which is running directly on the hardware.
>>
>> But this is not what appears to be happening in either your traces or
>> your code fragments.
>> André
>   
> I think everyone agrees that PO's x86 work will never be accepted by any
> scholarly journal. Shouldn't we be trying to avoid using it.
> 
> For starters we need a clear statement as to what is being proved complete
> with all the definitions a journal will require.
> 

// Simplified Linz Ĥ (Linz:1990:319)
void P(u32 x)
{
   u32 Input_Halts = H(x, x);
   if (Input_Halts)
     HERE: goto HERE;
}

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

I have proved that H correctly decides that P is a non-halting 
computation on the basis that P calls H in infinitely nested simulation. 
Computer scientists might notice that H and P are in their proper 
halting problem relation to each other.

-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#2964 — Re: Could H correctly decide that P never halts? [ Why can H ignore its own behavior? ](my thanks to Richard)

Fromolcott <NoOne@NoWhere.com>
Date2021-07-05 08:40 -0500
SubjectRe: Could H correctly decide that P never halts? [ Why can H ignore its own behavior? ](my thanks to Richard)
Message-ID<mL-dnd7DlOpLln79nZ2dnUU7-IGdnZ2d@giganews.com>
In reply to#2956
On 7/5/2021 7:05 AM, Richard Damon wrote:
> On 7/4/21 9:42 PM, olcott wrote:
>> On 7/4/2021 8:03 PM, dklei...@gmail.com wrote:
>>> On Sunday, July 4, 2021 at 1:55:27 PM UTC-7, André G. Isaak wrote:
>>>> On 2021-07-04 14:09, olcott wrote:
>>>>> On 7/4/2021 2:00 PM, André G. Isaak wrote:
>>>>>> On 2021-07-04 12:24, Malcolm McLean wrote:
>>>>>>
>>>>>>> The execution trace showed two calls to the "halts" subroutine.
>>>>>>> However it was stated that "halts" is a simulating decider.
>>>>>>> Therefore we
>>>>>>> have one call to halts. It then emulates another call to halts.
>>>>>>> But the
>>>>>>> second call to "halts" shouldn't appear on the execution trace. It's
>>>>>>> emulated.
>>>>>>>
>>>>>>> So exactly what the decider is doing remains a bit opaque.
>>>>>>
>>>>>> I've tried to get Olcott to clarify exactly what he means by
>>>>>> 'emulate'/'simulate' but to no avail. I'm fairly sure he doesn't mean
>>>>>> what the rest of the world means, but I still am unclear about what he
>>>>>> actually means.
>>>>>>
>>>>>> André
>>>>>>
>>>>>
>>>>> Sure everyone knows that an x86 emulator can be anything from a vanilla
>>>>> milkshake machine to a dump truck. What I mean by x86 emulator is
>>>>> software that executes x86 machine language as if this software virtual
>>>>> machine was an actual x86 processor.
>>>> The problem is that you keep talking about 'nested simulations' but
>>>> there's absolutely nothing in your code or your traces to suggest more
>>>> than a single level of emulation is involved.
>>>>
>>>> If your H *emulates* P, it should not contain a call to P. It should
>>>> contain a call to some function EMULATE with some description of P
>>>> (either a file or a memory location) as an *argument* to that function.
>>>> If that P includes an H which also emulates its input, there should be a
>>>> second call to EMULATE, meaning we should have one instance of the
>>>> emulator running on the actual hardware, and a second instance of the
>>>> emulator being interpreted by the first emulator rather than being run
>>>> on the actual hardware, and with a second instance of P being
>>>> interpreted by that emulated emulator rather than either the hardware or
>>>> the emulator which is running directly on the hardware.
>>>>
>>>> But this is not what appears to be happening in either your traces or
>>>> your code fragments.
>>>> André
>>>    I think everyone agrees that PO's x86 work will never be accepted by
>>> any
>>> scholarly journal. Shouldn't we be trying to avoid using it.
>>>
>>> For starters we need a clear statement as to what is being proved
>>> complete
>>> with all the definitions a journal will require.
>>>
>>
>> // Simplified Linz Ĥ (Linz:1990:319)
>> void P(u32 x)
>> {
>>    u32 Input_Halts = H(x, x);
>>    if (Input_Halts)
>>      HERE: goto HERE;
>> }
>>
>> int main()
>> {
>>    u32 Input_Halts = H((u32)P, (u32)P);
>>    Output("Input_Halts = ", Input_Halts);
>> }
>>
>> I have proved that H correctly decides that P is a non-halting
>> computation on the basis that P calls H in infinitely nested simulation.
>> Computer scientists might notice that H and P are in their proper
>> halting problem relation to each other.
>>
> 
> No, you haven't, because the scenerio you describe only happes if H is
> programmed never to abort the P that is built from it, in which case
> H(P,P) never answers, and thus deosn't need to be disproved, it did a
> good enough job at doing that itself.

Every H only acts as a pure x86 emulator until some P has demonstrated 
that it will never halt unless it is aborted.

Once it is fully understood that any computation that never halts unless 
its simulation is aborted is the correct non-halting criteria then it 
can be understood that H(P,P)==0 correct.

It can be easily verified that if no H ever aborts any P that P(P) will 
never halt. If any H must abort any P then this H does correctly decide 
that this P does not halt.



-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#2960 — Re: Could H correctly decide that P never halts? [ Why can H ignore its own behavior? ](my thanks to Richard)

Fromolcott <NoOne@NoWhere.com>
Date2021-07-04 23:52 -0500
SubjectRe: Could H correctly decide that P never halts? [ Why can H ignore its own behavior? ](my thanks to Richard)
Message-ID<ovOdnXA3d5iWDX_9nZ2dnUU7-ffNnZ2d@giganews.com>
In reply to#2955
On 7/4/2021 3:55 PM, André G. Isaak wrote:
> On 2021-07-04 14:09, olcott wrote:
>> On 7/4/2021 2:00 PM, André G. Isaak wrote:
>>> On 2021-07-04 12:24, Malcolm McLean wrote:
>>>
>>>> The execution trace showed two calls to the "halts" subroutine.
>>>> However it was stated that "halts" is a simulating decider. 
>>>> Therefore we
>>>> have one call to halts. It then emulates  another call to halts. But 
>>>> the
>>>> second call to "halts" shouldn't appear on the execution trace. It's 
>>>> emulated.
>>>>
>>>> So exactly what the decider is doing remains a bit opaque.
>>>
>>> I've tried to get Olcott to clarify exactly what he means by 
>>> 'emulate'/'simulate' but to no avail. I'm fairly sure he doesn't mean 
>>> what the rest of the world means, but I still am unclear about what 
>>> he actually means.
>>>
>>> André
>>>
>>
>> Sure everyone knows that an x86 emulator can be anything from a 
>> vanilla milkshake machine to a dump truck.  What I mean by x86 
>> emulator is software that executes x86 machine language as if this 
>> software virtual machine was an actual x86 processor.
> 
> The problem is that you keep talking about 'nested simulations' but 
> there's absolutely nothing in your code or your traces to suggest more 
> than a single level of emulation is involved.
> 

You must not know assembly x86 language at all.


// Simplified Linz Ĥ (Linz:1990:319)
void P(u32 x)
{
   u32 Input_Halts = H(x, x);   // call H 2nd level of simulation
   if (Input_Halts)
     HERE: goto HERE;
}


int main()
{
   u32 Input_Halts = H((u32)P, (u32)P); // call H 1st level of simulation
   Output("Input_Halts = ", Input_Halts);
}


_P()
[00000b1a](01)  55              push ebp
[00000b1b](02)  8bec            mov ebp,esp
[00000b1d](01)  51              push ecx
[00000b1e](03)  8b4508          mov eax,[ebp+08]
[00000b21](01)  50              push eax       // 2nd Param
[00000b22](03)  8b4d08          mov ecx,[ebp+08]
[00000b25](01)  51              push ecx       // 1st Param
[00000b26](05)  e81ffeffff      call 0000094a  // call H
[00000b2b](03)  83c408          add esp,+08
[00000b2e](03)  8945fc          mov [ebp-04],eax
[00000b31](04)  837dfc00        cmp dword [ebp-04],+00
[00000b35](02)  7402            jz 00000b39
[00000b37](02)  ebfe            jmp 00000b37
[00000b39](02)  8be5            mov esp,ebp
[00000b3b](01)  5d              pop ebp
[00000b3c](01)  c3              ret
Size in bytes:(0035) [00000b3c]

_main()
[00000bda](01)  55              push ebp
[00000bdb](02)  8bec            mov ebp,esp
[00000bdd](01)  51              push ecx
[00000bde](05)  681a0b0000      push 00000b1a  // push address of P
[00000be3](05)  681a0b0000      push 00000b1a  // push address of P
[00000be8](05)  e85dfdffff      call 0000094a  // call H
[00000bed](03)  83c408          add esp,+08
[00000bf0](03)  8945fc          mov [ebp-04],eax
[00000bf3](03)  8b45fc          mov eax,[ebp-04]
[00000bf6](01)  50              push eax
[00000bf7](05)  683b030000      push 0000033b
[00000bfc](05)  e869f7ffff      call 0000036a
[00000c01](03)  83c408          add esp,+08
[00000c04](02)  33c0            xor eax,eax
[00000c06](02)  8be5            mov esp,ebp
[00000c08](01)  5d              pop ebp
[00000c09](01)  c3              ret
Size in bytes:(0048) [00000c09]

Columns
(1) Machine address of instruction
(2) Machine address of top of stack
(3) Value of top of stack after instruction executed
(4) Machine language bytes
(5) Assembly language text
===============================
...[00000bda][00101647][00000000](01)  55              push ebp
...[00000bdb][00101647][00000000](02)  8bec            mov ebp,esp
...[00000bdd][00101643][00000000](01)  51              push ecx
...[00000bde][0010163f][00000b1a](05)  681a0b0000      push 00000b1a // 
push P
...[00000be3][0010163b][00000b1a](05)  681a0b0000      push 00000b1a // 
push P
...[00000be8][00101637][00000bed](05)  e85dfdffff      call 0000094a // 
call H

Begin Local Halt Decider Simulation at Machine Address:b1a
...[00000b1a][002116e7][002116eb](01)  55              push ebp
...[00000b1b][002116e7][002116eb](02)  8bec            mov ebp,esp
...[00000b1d][002116e3][002016b7](01)  51              push ecx
...[00000b1e][002116e3][002016b7](03)  8b4508          mov eax,[ebp+08]
...[00000b21][002116df][00000b1a](01)  50              push eax      // 
push P
...[00000b22][002116df][00000b1a](03)  8b4d08          mov ecx,[ebp+08]
...[00000b25][002116db][00000b1a](01)  51              push ecx      // 
push P
...[00000b26][002116d7][00000b2b](05)  e81ffeffff      call 0000094a // 
call H
...[00000b1a][0025c10f][0025c113](01)  55              push ebp
...[00000b1b][0025c10f][0025c113](02)  8bec            mov ebp,esp
...[00000b1d][0025c10b][0024c0df](01)  51              push ecx
...[00000b1e][0025c10b][0024c0df](03)  8b4508          mov eax,[ebp+08]
...[00000b21][0025c107][00000b1a](01)  50              push eax      // 
push P
...[00000b22][0025c107][00000b1a](03)  8b4d08          mov ecx,[ebp+08]
...[00000b25][0025c103][00000b1a](01)  51              push ecx      // 
push P
...[00000b26][0025c0ff][00000b2b](05)  e81ffeffff      call 0000094a // 
call H
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

In the above 16 instructions of the simulation of P(P) we can see that 
the first 8 instructions of P are repeated. The end of this sequence of 
8 instructions P calls H with its own machine address as the parameters 
to H: H(P,P). Because H only examines the behavior of its inputs and 
ignores its own behavior when H(P,P) is called we only see the first 
instruction of P being simulated.

Anyone knowing the x86 language well enough can see that none of these 8 
simulated instructions of P have any escape from their infinitely 
repeating behavior pattern. When H recognizes this infinitely repeating 
pattern it aborts its simulation of P(P) and reports that its input: 
(P,P) would never halt on its input.



> If your H *emulates* P, it should not contain a call to P. It should 
> contain a call to some function EMULATE with some description of P 
> (either a file or a memory location) as an *argument* to that function. 
> If that P includes an H which also emulates its input, there should be a 
> second call to EMULATE, meaning we should have one instance of the 
> emulator running on the actual hardware, and a second instance of the 
> emulator being interpreted by the first emulator rather than being run 
> on the actual hardware, and with a second instance of P being 
> interpreted by that emulated emulator rather than either the hardware or 
> the emulator which is running directly on the hardware.
> 
> But this is not what appears to be happening in either your traces or 
> your code fragments.
> 
> André
> 


-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#2965 — Re: Could H correctly decide that P never halts? [ Why can H ignore its own behavior? ](my thanks to Richard)

Fromolcott <NoOne@NoWhere.com>
Date2021-07-05 09:31 -0500
SubjectRe: Could H correctly decide that P never halts? [ Why can H ignore its own behavior? ](my thanks to Richard)
Message-ID<-fmdnRFMw7NTin79nZ2dnUU7-UnNnZ2d@giganews.com>
In reply to#2955
On 7/5/2021 9:18 AM, Malcolm McLean wrote:
> On Monday, 5 July 2021 at 14:23:35 UTC+1, olcott wrote:
>> On 7/4/2021 3:30 PM, Malcolm McLean wrote:
>>> On Sunday, 4 July 2021 at 21:09:27 UTC+1, olcott wrote:
>>>> On 7/4/2021 2:00 PM, André G. Isaak wrote:
>>>>> On 2021-07-04 12:24, Malcolm McLean wrote:
>>>>>
>>>>>> The execution trace showed two calls to the "halts" subroutine.
>>>>>> However it was stated that "halts" is a simulating decider. Therefore we
>>>>>> have one call to halts. It then emulates another call to halts. But the
>>>>>> second call to "halts" shouldn't appear on the execution trace. It's
>>>>>> emulated.
>>>>>>
>>>>>> So exactly what the decider is doing remains a bit opaque.
>>>>>
>>>>> I've tried to get Olcott to clarify exactly what he means by
>>>>> 'emulate'/'simulate' but to no avail. I'm fairly sure he doesn't mean
>>>>> what the rest of the world means, but I still am unclear about what he
>>>>> actually means.
>>>>>
>>>>> André
>>>>>
>>>> Sure everyone knows that an x86 emulator can be anything from a vanilla
>>>> milkshake machine to a dump truck. What I mean by x86 emulator is
>>>> software that executes x86 machine language as if this software virtual
>>>> machine was an actual x86 processor.
>>>>
>>> What I understand by an emulator is something which spins up a virtual
>>> enviornment - a struct containing registers, an area of memory, and
>>> maybe other bits and bats. Then the core of the program is a switch on the
>>> opcode pointed to by the instruction pointer. It then manipulates the
>>> virtual environment in the same way as a real machine.
>>>
>> When the OS is Windows or Linux the whole infrastructure of an x86
>> emulator must be built from scratch. When the OS is an x86 emulator the
>> infrastructure already exists.
>>
> Normally an emulator doesn't grant emulated programs access to the OS. They
> run in their own little sandbox.

The entire OS is one big sandbox.

>>
>>> So if we see "call 0x12345678" we don't make a jump to address 12345678.
>>> Instead we go to the switch case that handles "call". This will push the
>>> virtual instruction pointer on to a stack, and set it to "12345678". Then on
>>> the next pass the virtual instruction pointer is "12345678" and we load the
>>> instruction at that address and switch on the opcode.
>>>
>> In the above case inside an x86 emulator a call to a function is simply
>> a call to a function.
>>
> In my understanding, a call in an emulated program is an emulated call.

Yes. There are 26,419 execution steps that are not shown.
None of these steps have any effect on the behavior of the input.
So far no one has fully understood the 33 steps that I have posted in 
any of the many times that I have posted them in the last four months.

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

> The emulator executes some code like "push current address on stack,
> set program counter to call address".
> SO there's something weird about your emulator.
> 

Since no one here could begin to understand 33 steps it makes perfect 
sense for the emulator to screen out all of the steps that cannot 
possibly effect the behavior of its input. An extra 400 pages of 
execution trace cannot possibly make my proof easier to understand.

-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#2969

Fromolcott <NoOne@NoWhere.com>
Date2021-07-05 17:38 -0500
Message-ID<jqWdnYcQk85gFH79nZ2dnUU7-T_NnZ2d@giganews.com>
In reply to#2955
On 7/5/2021 12:49 PM, Mike Terry wrote:
> On 05/07/2021 06:20, Jeff Barnett wrote:
>> On 7/4/2021 7:03 PM, dklei...@gmail.com wrote:
>>> On Sunday, July 4, 2021 at 1:55:27 PM UTC-7, André G. Isaak wrote:
>>>> On 2021-07-04 14:09, olcott wrote:
>>>>> On 7/4/2021 2:00 PM, André G. Isaak wrote:
>>>>>> On 2021-07-04 12:24, Malcolm McLean wrote:
>>>>>>
>>>>>>> The execution trace showed two calls to the "halts" subroutine.
>>>>>>> However it was stated that "halts" is a simulating decider. 
>>>>>>> Therefore we
>>>>>>> have one call to halts. It then emulates another call to halts. 
>>>>>>> But the
>>>>>>> second call to "halts" shouldn't appear on the execution trace. It's
>>>>>>> emulated.
>>>>>>>
>>>>>>> So exactly what the decider is doing remains a bit opaque.
>>>>>>
>>>>>> I've tried to get Olcott to clarify exactly what he means by
>>>>>> 'emulate'/'simulate' but to no avail. I'm fairly sure he doesn't mean
>>>>>> what the rest of the world means, but I still am unclear about 
>>>>>> what he
>>>>>> actually means.
>>>>>>
>>>>>> André
>>>>>>
>>>>>
>>>>> Sure everyone knows that an x86 emulator can be anything from a 
>>>>> vanilla
>>>>> milkshake machine to a dump truck. What I mean by x86 emulator is
>>>>> software that executes x86 machine language as if this software 
>>>>> virtual
>>>>> machine was an actual x86 processor.
>>>> The problem is that you keep talking about 'nested simulations' but
>>>> there's absolutely nothing in your code or your traces to suggest more
>>>> than a single level of emulation is involved.
>>>>
>>>> If your H *emulates* P, it should not contain a call to P. It should
>>>> contain a call to some function EMULATE with some description of P
>>>> (either a file or a memory location) as an *argument* to that function.
>>>> If that P includes an H which also emulates its input, there should 
>>>> be a
>>>> second call to EMULATE, meaning we should have one instance of the
>>>> emulator running on the actual hardware, and a second instance of the
>>>> emulator being interpreted by the first emulator rather than being run
>>>> on the actual hardware, and with a second instance of P being
>>>> interpreted by that emulated emulator rather than either the 
>>>> hardware or
>>>> the emulator which is running directly on the hardware.
>>>>
>>>> But this is not what appears to be happening in either your traces or
>>>> your code fragments.
>>>> André
>>> I think everyone agrees that PO's x86 work will never be accepted by any
>>> scholarly journal. Shouldn't we be trying to avoid using it.
>>>
>>> For starters we need a clear statement as to what is being proved 
>>> complete
>>> with all the definitions a journal will require.
>>
>> And why in hell should we bother to try and get a clear statement. 
> 
> Personally, I wouldn't, for the reasons you say below.  But I suspect DK 
> is just saying that a clear statement is a pre-requisite for PO 
> publishing, not that /we/ have some duty to try to get one from him, 
> which would be quite fruitless.
> 
>> The
>> idea that our ignoramus/troll will ever submit anything to a refereed 
>> journal is fatuous. He will never acquire the ability to clearly 
>> state, formulate, or prove any interesting conjecture. All he will 
>> ever do, all he wants to do is participate in these ridiculous 
>> dialogues; repeat, rewind, repeat again, and on and on. He enjoys 
>> defeating every one of us even when he "acknowledges a flaw". Then he 
>> rewinds, repeats and doesn't miss a beat never admitting the 
>> acknowledgement nor retracting it. You cannot win this game because 
>> he's in it for the game, not the outcome.
> 
> I think PO /wants/ to do more than just argue here, and convinces 
> himself that one day he will do that.  So he is not trolling (mostly), 
> but is just severely Deluded.  His statements seem a bit like 
> confabulation, where patients invent fantastical stories to cover gaps 
> in their memories.  Those patients are not lying as such, they're just 
> saying things which make sense to them.
> 
> PO doesn't have a memory impairment as far as I can tell, but I wonder 
> whether similar confabulation can occur when someone has an intellectual 
> reasoning impairment: they invent "fantastical logic" to explain their 
> unreasoned intuitions, without understanding that to other people those 
> explanations are ridiculous.  (E.g. PO convincing himself that a 
> computation that demonstrably halts is correctly classified as 
> non-halting, because that was his first intuition before he actually 
> tried it, and he can't abandon that intuition, which trumps any logic 
> from other people.  (And apparently trumps reality in this case!))
> 


void P(u32 x)
{
   u32 Input_Halts = H(x, x);
   if (Input_Halts)
     HERE: goto HERE;
}

int main()
{
   P((u32)P);
}

If you weren't dumber than a box of rocks you would understand that the 
above computation never halts unless it is aborted at some point.

The above statement assumes the context of this paper
(where H is a simulating halt decider based on an x86 emulator):

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

> Such a person simply wouldn't realise that other people are genuinely 
> /reasoning logically/ about these abstract ideas, and that terms and 
> phrases they use have precise technical meanings that the everyone else 
> /understands/.  To such a person, it would seem that other people are 
> just doing the same as them: half understanding stuff and spouting vague 
> words and magical phrases to "prove" things, which is exactly what the 
> logically impaired person is doing - so why does everyone take other 
> peoples' proofs seriously but not theirs?  It must be quite frustrating!
> 
> You're right that we can't "win" the PO "game", but that's alright - PO 
> is harmless, and nobody should feel he needs to be "defeated".  And it's 
> simply not possible IMO to genuinely /help/ him, so what needs to be 
> done?  Er, nothing. :)
> 
> 
> Mike.
> 


-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#2961 — Re: Could H correctly decide that P never halts? [ Why can H ignore its own behavior? ](my thanks to Richard)

Fromolcott <NoOne@NoWhere.com>
Date2021-07-05 08:07 -0500
SubjectRe: Could H correctly decide that P never halts? [ Why can H ignore its own behavior? ](my thanks to Richard)
Message-ID<g4OdnfHJaMWFmX79nZ2dnUU7-aPNnZ2d@giganews.com>
In reply to#2952
On 7/4/2021 11:31 AM, André G. Isaak wrote:
> On 2021-07-04 08:15, olcott wrote:
>> On 7/4/2021 1:50 AM, André G. Isaak wrote:
>>> On 2021-07-03 22:18, olcott wrote:
>>>> On 7/3/2021 11:14 PM, André G. Isaak wrote:
>>>>> On 2021-07-03 19:38, olcott wrote:
>>>>>> On 7/3/2021 8:14 PM, André G. Isaak wrote:
>>>>>>> On 2021-07-03 14:37, olcott wrote:
>>>>>>>
>>>>>>>> It can always ignore it own behavior and it can do this by 
>>>>>>>> screening out machine address ranges to be ignored. H ignores 
>>>>>>>> all of its own behavior and the behavior or every operating 
>>>>>>>> system function.
>>>>>>>
>>>>>>> And in what universe does it make sense to simply ignore 
>>>>>>> operating system functions? 
>>>>>>
>>>>>> When making a halt deciding function it only makes sense to keep 
>>>>>> track of those aspects of computations that can cause the input to 
>>>>>> halt.
>>>>>
>>>>> And what on earth would lead you to believe that a system call 
>>>>> could have no impact on halting?
>>>>>
>>>>> (You conveniently skipped the example I gave.)
>>>>>
>>>>> André
>>>>>
>>>>
>>>> I am the only author of the entire x86utm operating system and all 
>>>> of its functions.
>>>
>>> And we're just supposed to take your word for it that these can 
>>> legitimately be ignored?
>>>
>>> Given that you've claimed that the instance of H called from within P 
>>> doesn't affect halting when it clearly does, your word isn't going to 
>>> carry much weight here.
>>>
>>
>> No instance of any H has any effect on any P until some P proves that 
>> it will never halt unless aborted. This has always been able to be 
>> directly verified by the assembly language execution trace of P 
>> relative to its assembly language source code.
> 
> P doesn't "prove" anything. It's the copy of H embedded in P that makes 
> the determination. And once it makes this determination it *does* affect 
> the behaviour.
> 

Every H only acts as a pure x86 emulator until some P has demonstrated 
that it will never halt unless it is aborted.

Once it is  fully understood that any computation that never halts 
unless its simulation is aborted is the correct non-halting criteria 
then it can be understood that H(P,P)==0 correct.

It can be easily verified that if no H ever aborts any P that P(P) will 
never halt. If any H must abort any P then this H does correctly decide 
that this P does not halt.

> So what you're saying essentially is that H doesn't affect the behaviour 
> of P until it does. Which means that H *can* affect the behaviour of P. 
> Which means the code of H must be included in your analysis.
> 

While H is analyzing the behavior of P it has no effect what-so-ever on 
the behavior of P. H only has an effect on the behavior of P after P has 
proven that it will never halt unless aborted.

> And note that your previous phraseology, that "H behaves as a pure 
> simulator until it decides that there is infinite recursion" (or 
> something to that effect) is misleading.
> 
> A "pure simulator" would be one that simply simulates its input. It 
> doesn't do other things like try to determine whether a given input 
> matches one of your "patterns". So unless it is your claim that H 

It is functionally equivalent to a pure simulator in that it has no 
effect what-so-ever on the behavior of its input.

> doesn't attempt to determine whether its input matches one of these 
> patterns until after it determines that one of these patterns is matches 
> (an obviously nonsensical claim), your H does *not* act as a pure 
> simulator either before or after it detects recursion. Prior to 
> detecting this recursion it is still performing tests, and those tests 
> will include conditional branches of exactly the same sort that are 
> relevant to your 'infinite recursion pattern'. You can't simply skip 
> over these tests as if they didn't matter since it's these exact tests 
> that *prevent* infinite recursion from actually occuring.
> 

I can skip over those tests knowing that they will have no effect on the 
behavior of the input until after the input has proven beyond all 
possibly doubt that it will never halt unless aborted.

> 
>> This has been available posted directly in this forum since
>> On 3/14/2021 12:46 PM, olcott wrote:
>>
>> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation 
>>
>>
>>> If it really were the case that these things didn't have any affect 
>>> on halting, then it would also be perfectly fine for your halt 
>>> decider to *not* skip this code in its analysis, and that would avoid 
>>> objections 
>>
>> Most importantly you can easily verify for yourself that P is 
>> accurately simulated by comparing its x86 source code to its x86 
>> execution trace.
> 
> Nothing can be verified from a *partial* trace which is all you have 
> given. 

It can be easily verified that the trace is complete (up to its point of 
infinite execution) by comparing the trace to the assembly language 
source-code of P. That this has been continuously available since March 
and no one bothered to look at it indicates one of two things:

(1) The reviewers do not understand the x86 language.

(2) The reviewers do not care about what the truth is. They are only 
interested in providing rebuttals even if I am correct.

> But even your partial trace is sufficient to recognize that your 
> H's underlying logic is flawed since it skips critical portions of the 
> code.
> 

Because H acts as a simulator and thus has no effect on the execution of 
its input until after its input has proven that it will never halt 
unless aborted H can correctly ignore its own behavior in this execution 
trace.

>> That no one has bothered to do this since March 14 would seem to 
>> indicate that no one here knows assembly language besides me.
> 
> Lots of people here know assembly language. I suspect that many people 
> here know it far better than you do.
> 
> André
> 



-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#2962 — Re: Could H correctly decide that P never halts? [ Why can H ignore its own behavior? ](my thanks to Richard)

Fromolcott <NoOne@NoWhere.com>
Date2021-07-05 08:18 -0500
SubjectRe: Could H correctly decide that P never halts? [ Why can H ignore its own behavior? ](my thanks to Richard)
Message-ID<_pOdnT5w15EGm379nZ2dnUU7-cfNnZ2d@giganews.com>
In reply to#2952
On 7/4/2021 1:24 PM, Malcolm McLean wrote:
> On Sunday, 4 July 2021 at 15:15:46 UTC+1, olcott wrote:
>> On 7/4/2021 1:50 AM, André G. Isaak wrote:
>>> On 2021-07-03 22:18, olcott wrote:
>>>> On 7/3/2021 11:14 PM, André G. Isaak wrote:
>>>>> On 2021-07-03 19:38, olcott wrote:
>>>>>> On 7/3/2021 8:14 PM, André G. Isaak wrote:
>>>>>>> On 2021-07-03 14:37, olcott wrote:
>>>>>>>
>>>>>>>> It can always ignore it own behavior and it can do this by
>>>>>>>> screening out machine address ranges to be ignored. H ignores all
>>>>>>>> of its own behavior and the behavior or every operating system
>>>>>>>> function.
>>>>>>>
>>>>>>> And in what universe does it make sense to simply ignore operating
>>>>>>> system functions?
>>>>>>
>>>>>> When making a halt deciding function it only makes sense to keep
>>>>>> track of those aspects of computations that can cause the input to
>>>>>> halt.
>>>>>
>>>>> And what on earth would lead you to believe that a system call could
>>>>> have no impact on halting?
>>>>>
>>>>> (You conveniently skipped the example I gave.)
>>>>>
>>>>> André
>>>>>
>>>>
>>>> I am the only author of the entire x86utm operating system and all of
>>>> its functions.
>>>
>>> And we're just supposed to take your word for it that these can
>>> legitimately be ignored?
>>>
>>> Given that you've claimed that the instance of H called from within P
>>> doesn't affect halting when it clearly does, your word isn't going to
>>> carry much weight here.
>>>
>> No instance of any H has any effect on any P until some P proves that it
>> will never halt unless aborted. This has always been able to be directly
>> verified by the assembly language execution trace of P relative to its
>> assembly language source code.
>>
>> This has been available posted directly in this forum since
>> On 3/14/2021 12:46 PM, olcott wrote:
>>
>> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
>>> If it really were the case that these things didn't have any affect on
>>> halting, then it would also be perfectly fine for your halt decider to
>>> *not* skip this code in its analysis, and that would avoid objections
>> Most importantly you can easily verify for yourself that P is accurately
>> simulated by comparing its x86 source code to its x86 execution trace.
>>
>> That no one has bothered to do this since March 14 would seem to
>> indicate that no one here knows assembly language besides me.
>>
>> I have proven that H has no effect on its input since March 13 and the
>> 16 lines of execution trace of the input proved to be totally
>> overwhelming for everyone here. Adding 26,000 lines of more code would
>> not help.
>>
> The execution trace showed two calls to the "halts" subroutine.
> However it was stated that "halts" is a simulating decider. Therefore we
> have one call to halts. It then emulates  another call to halts. But the
> second call to "halts" shouldn't appear on the execution trace. It's emulated.
> 
> So exactly what the decider is doing remains a bit opaque.
> 

Software emulators have all of the details of subordinate emulations as 
their own data. H makes sure to ignore every address of itself and all 
operating system functions because neither OS functions nor itself have 
any effect on the behavior of the input while the input is being simulated.


-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


Page 1 of 2  [1] 2  Next page →

Back to top | Article view | comp.software-eng


csiph-web