Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  newsreader  groups  login

Message-ID:  

The moving cursor writes, and having written, blinks on.


devel / comp.theory / Re: Olcott wrong about infinite recursion [ simplest rebuttal of halting theorem ]

SubjectAuthor
* Olcott wrong about infinite recursionMr Flibble
`* Olcott wrong about infinite recursion [ H as a pure function ]olcott
 `* Olcott wrong about infinite recursion [ H as a pure function ]Richard Damon
  `* Olcott wrong about infinite recursion [ H as a pure function ]Mr Flibble
   `* Olcott wrong about infinite recursion [ simplest rebuttal ofolcott
    +* Olcott wrong about infinite recursion [ simplest rebuttal ofRichard Damon
    |`* Olcott wrong about infinite recursion [ simplest rebuttal ofolcott
    | `* Olcott wrong about infinite recursion [ simplest rebuttal ofRichard Damon
    |  `* Olcott wrong about infinite recursion [ simplest rebuttal ofolcott
    |   `* Olcott wrong about infinite recursion [ simplest rebuttal ofRichard Damon
    |    `* Olcott wrong about infinite recursion [ simplest rebuttal ofolcott
    |     `* Olcott wrong about infinite recursion [ simplest rebuttal ofRichard Damon
    |      `* Olcott wrong about infinite recursion [ simplest rebuttal ofolcott
    |       `* Olcott wrong about infinite recursion [ simplest rebuttal ofRichard Damon
    |        `* Olcott wrong about infinite recursion [ simplest rebuttal ofolcott
    |         `* Olcott wrong about infinite recursion [ simplest rebuttal ofRichard Damon
    |          `* Olcott wrong about infinite recursion [ simplest rebuttal of halting theorem ] [olcott
    |           `* Olcott wrong about infinite recursion [ simplest rebuttal ofRichard Damon
    |            `* Olcott wrong about infinite recursion [ simplest rebuttal of halting theorem ] [olcott
    |             `* Olcott wrong about infinite recursion [ simplest rebuttal ofRichard Damon
    |              `* Olcott wrong about infinite recursion [ simplest rebuttal of halting theorem ] [olcott
    |               `* Olcott wrong about infinite recursion [ simplest rebuttal ofRichard Damon
    |                `* Olcott wrong about infinite recursion [ simplest rebuttal of halting theorem ] [olcott
    |                 `* Olcott wrong about infinite recursion [ simplest rebuttal ofRichard Damon
    |                  `* Olcott wrong about infinite recursion [ simplest rebuttal ofolcott
    |                   `* Olcott wrong about infinite recursion [ simplest rebuttal ofRichard Damon
    |                    `* Olcott wrong about infinite recursion [ simplest rebuttal ofolcott
    |                     `* Olcott wrong about infinite recursion [ simplest rebuttal ofRichard Damon
    |                      +* Olcott wrong about infinite recursion [ simplest rebuttal ofolcott
    |                      |`- Olcott wrong about infinite recursion [ simplest rebuttal ofRichard Damon
    |                      `* Olcott wrong about infinite recursion [ simplest rebuttal ofAndré G. Isaak
    |                       `* Olcott wrong about infinite recursion [ simplest rebuttal ofolcott
    |                        +- Olcott wrong about infinite recursion [ simplest rebuttal ofRichard Damon
    |                        `- Olcott wrong about infinite recursion [ simplest rebuttal ofAndré G. Isaak
    `* Olcott wrong about infinite recursion [ simplest rebuttal ofMr Flibble
     `- Olcott wrong about infinite recursion [ simplest rebuttal ofolcott

Pages:12
Olcott wrong about infinite recursion

<20211110215316.0000221e@reddwarf.jmc>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=23272&group=comp.theory#23272

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!newsreader4.netcologne.de!news.netcologne.de!peer02.ams1!peer.ams1.xlned.com!news.xlned.com!peer01.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx03.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc (Mr Flibble)
Newsgroups: comp.theory
Subject: Olcott wrong about infinite recursion
Message-ID: <20211110215316.0000221e@reddwarf.jmc>
Organization: Jupiter Mining Corp
X-Newsreader: Claws Mail 3.17.8 (GTK+ 2.24.33; x86_64-w64-mingw32)
MIME-Version: 1.0
Content-Type: text/plain; charset=US-ASCII
Content-Transfer-Encoding: 7bit
Lines: 10
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Wed, 10 Nov 2021 21:53:15 UTC
Date: Wed, 10 Nov 2021 21:53:16 +0000
X-Received-Bytes: 913
 by: Mr Flibble - Wed, 10 Nov 2021 21:53 UTC

Olcott is barking up the wrong tree re infinite recursion: there
is only a need to detect a single recursive call into the halt decider
and signal an exception. Why? Because infinite recursion is valid
program behavior.

/Flibble

--
This message is a troll.

Re: Olcott wrong about infinite recursion [ H as a pure function ]

<ApydnX6D6fN31RH8nZ2dnUU7-UXNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=23276&group=comp.theory#23276

 copy link   Newsgroups: comp.theory sci.logic sci.math comp.software-eng
Followup: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!newsreader4.netcologne.de!news.netcologne.de!peer02.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Wed, 10 Nov 2021 16:34:18 -0600
Date: Wed, 10 Nov 2021 16:34:17 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.3.0
Subject: Re: Olcott wrong about infinite recursion [ H as a pure function ]
Content-Language: en-US
Newsgroups: comp.theory,sci.logic,sci.math,comp.software-eng
References: <20211110215316.0000221e@reddwarf.jmc>
From: NoO...@NoWhere.com (olcott)
Followup-To: comp.theory
In-Reply-To: <20211110215316.0000221e@reddwarf.jmc>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <ApydnX6D6fN31RH8nZ2dnUU7-UXNnZ2d@giganews.com>
Lines: 57
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-TmBOvpPOrqtzmxxVyRpSF7IWGonUrBFQ1htB0UZwJpgb+tyTFYupRxCrVqO4Ibl/zvt5HuTzH9QH0eT!OlrNyi/hIVPqS5zaCh28zkNcluUXVooqQYovfDQls59W3PH7rRmRD8E7P2/WEd/zG/csWoAROQ+s!lA==
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 3164
X-Received-Bytes: 3343
 by: olcott - Wed, 10 Nov 2021 22:34 UTC

On 11/10/2021 3:53 PM, Mr Flibble wrote:
> Olcott is barking up the wrong tree re infinite recursion: there
> is only a need to detect a single recursive call into the halt decider
> and signal an exception.

Yes, I figured that out. That eliminates the need for static local data
thus allowing the halt decider to be a pure function.

https://en.wikipedia.org/wiki/Pure_function

That is why I needed my source-code analyzer to provide the exact number
of parameters to every function.

As long as the currently executing function (H) is called again with the
same parameters then we know that this call will be infinitely recursive
unless this infinite recursion is aborted at some point.

When H aborts this call to itself made by P then P never reaches its
final state. If H never aborts this call made by P then P never reaches
its final state. This conclusively proves that H can abort this call to
itself and report that its input never halts.

Here is the reference to my NumParams system:
On 10/23/2021 8:27 PM, olcott wrote:
[I finally completed my lexical analyzer generator (needed by my halt
decider)]
This system uses a DFA lexical analyzer to recognize
the pattern of function declarations. This pattern is
specified as 15 DFA states. The output is a C header
file that looks up the function name specified in the
COFF object file and returns its number of parameters.

Halting problem undecidability and infinitely nested simulation (V2)

https://www.researchgate.net/publication/356105750_Halting_problem_undecidability_and_infinitely_nested_simulation_V2

> Why? Because infinite recursion is valid
> program behavior.
>
> /Flibble
>
> --
> This message is a troll.
>

--
Copyright 2021 Pete Olcott

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

Re: Olcott wrong about infinite recursion [ H as a pure function ]

<PFZiJ.19745$cW6.10169@fx08.iad>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=23284&group=comp.theory#23284

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!newsreader4.netcologne.de!news.netcologne.de!peer01.ams1!peer.ams1.xlned.com!news.xlned.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx08.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.3.0
Subject: Re: Olcott wrong about infinite recursion [ H as a pure function ]
Content-Language: en-US
Newsgroups: comp.theory
References: <20211110215316.0000221e@reddwarf.jmc>
<ApydnX6D6fN31RH8nZ2dnUU7-UXNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <ApydnX6D6fN31RH8nZ2dnUU7-UXNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 97
Message-ID: <PFZiJ.19745$cW6.10169@fx08.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Wed, 10 Nov 2021 19:42:23 -0500
X-Received-Bytes: 4575
 by: Richard Damon - Thu, 11 Nov 2021 00:42 UTC

On 11/10/21 5:34 PM, olcott wrote:
> On 11/10/2021 3:53 PM, Mr Flibble wrote:
>> Olcott is barking up the wrong tree re infinite recursion: there
>> is only a need to detect a single recursive call into the halt decider
>> and signal an exception.
>
> Yes, I figured that out. That eliminates the need for static local data
> thus allowing the halt decider to be a pure function.

Except that this logic is only correct if the function is being executed
under unconditional execution.

If the 'simulation' is being run under condition that can/will terminate
its execution, then the detection of this recursion is NOT proof that
the execution will be non-halting.

All you have show is that IF the decider would never abort its
'simulation' then the program would be non-halting.

Since it turns out that the decider DOES abort its 'simulation', the
assumptions that the analysis was done under are not in fact true, so
the analysis is invalid.

>
> https://en.wikipedia.org/wiki/Pure_function

But Software Engineering 'Pure Function' is NOT the Compution Theory
'Computation', so you need to be aware of the difference.

>
> That is why I needed my source-code analyzer to provide the exact number
> of parameters to every function.
>
> As long as the currently executing function (H) is called again with the
> same parameters then we know that this call will be infinitely recursive
> unless this infinite recursion is aborted at some point.

Right, it would be infinite if NEVER aborted, but it IS aborted, so it
is not infinite, and since the machine uses a copy of the decider, that
same fact applies to it being run as an indepent computation, since the
decider inside it does abort its internal simulation, it return the
answer that allows the actual computation to be finint.

>
> When H aborts this call to itself made by P then P never reaches its
> final state. If H never aborts this call made by P then P never reaches
> its final state. This conclusively proves that H can abort this call to
> itself and report that its input never halts.

But it doensn't matter that H's PARTIAL simulation of P reached the
halting point. When we run the actual computation, or give this input to
a REAL pure simulator, it will Halt.
>
>
>
> Here is the reference to my NumParams system:
> On 10/23/2021 8:27 PM, olcott wrote:
> [I finally completed my lexical analyzer generator (needed by my halt
> decider)]
> This system uses a DFA lexical analyzer to recognize
> the pattern of function declarations. This pattern is
> specified as 15 DFA states. The output is a C header
> file that looks up the function name specified in the
> COFF object file and returns its number of parameters.
>
>

And where does this code get the source code of the program whose
COMPILED form has been given to H?

Or, is H now being given the source code as the representation?

Remember, if you do that, then that source code needs to contain the
FULL description of the program, which includes the code for H, and
everything it uses, which includes your NumParams and the compiler you
are going to put that code into.

>
>
> Halting problem undecidability and infinitely nested simulation (V2)
>
> https://www.researchgate.net/publication/356105750_Halting_problem_undecidability_and_infinitely_nested_simulation_V2
>
>
>> Why?  Because infinite recursion is valid
>> program behavior.
>>
>> /Flibble
>>
>> --
>> This message is a troll.
>>
>
>

Re: Olcott wrong about infinite recursion [ H as a pure function ]

<20211111175240.00000a3b@reddwarf.jmc>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=23329&group=comp.theory#23329

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!newsreader4.netcologne.de!news.netcologne.de!peer03.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx01.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc (Mr Flibble)
Newsgroups: comp.theory
Subject: Re: Olcott wrong about infinite recursion [ H as a pure function ]
Message-ID: <20211111175240.00000a3b@reddwarf.jmc>
References: <20211110215316.0000221e@reddwarf.jmc>
<ApydnX6D6fN31RH8nZ2dnUU7-UXNnZ2d@giganews.com>
<PFZiJ.19745$cW6.10169@fx08.iad>
Organization: Jupiter Mining Corp
X-Newsreader: Claws Mail 3.17.8 (GTK+ 2.24.33; x86_64-w64-mingw32)
MIME-Version: 1.0
Content-Type: text/plain; charset=US-ASCII
Content-Transfer-Encoding: 7bit
Lines: 92
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Thu, 11 Nov 2021 17:52:39 UTC
Date: Thu, 11 Nov 2021 17:52:40 +0000
X-Received-Bytes: 4510
 by: Mr Flibble - Thu, 11 Nov 2021 17:52 UTC

On Wed, 10 Nov 2021 19:42:23 -0500
Richard Damon <Richard@Damon-Family.org> wrote:

> On 11/10/21 5:34 PM, olcott wrote:
> > On 11/10/2021 3:53 PM, Mr Flibble wrote:
> >> Olcott is barking up the wrong tree re infinite recursion: there
> >> is only a need to detect a single recursive call into the halt
> >> decider and signal an exception.
> >
> > Yes, I figured that out. That eliminates the need for static local
> > data thus allowing the halt decider to be a pure function.
>
> Except that this logic is only correct if the function is being
> executed under unconditional execution.
>
> If the 'simulation' is being run under condition that can/will
> terminate its execution, then the detection of this recursion is NOT
> proof that the execution will be non-halting.
>
> All you have show is that IF the decider would never abort its
> 'simulation' then the program would be non-halting.
>
> Since it turns out that the decider DOES abort its 'simulation', the
> assumptions that the analysis was done under are not in fact true, so
> the analysis is invalid.
>
>
> >
> > https://en.wikipedia.org/wiki/Pure_function
>
> But Software Engineering 'Pure Function' is NOT the Compution Theory
> 'Computation', so you need to be aware of the difference.
>
> >
> > That is why I needed my source-code analyzer to provide the exact
> > number of parameters to every function.
> >
> > As long as the currently executing function (H) is called again
> > with the same parameters then we know that this call will be
> > infinitely recursive unless this infinite recursion is aborted at
> > some point.
>
> Right, it would be infinite if NEVER aborted, but it IS aborted, so
> it is not infinite, and since the machine uses a copy of the decider,
> that same fact applies to it being run as an indepent computation,
> since the decider inside it does abort its internal simulation, it
> return the answer that allows the actual computation to be finint.
>
> >
> > When H aborts this call to itself made by P then P never reaches
> > its final state. If H never aborts this call made by P then P never
> > reaches its final state. This conclusively proves that H can abort
> > this call to itself and report that its input never halts.
>
>
> But it doensn't matter that H's PARTIAL simulation of P reached the
> halting point. When we run the actual computation, or give this input
> to a REAL pure simulator, it will Halt.
> >
> >
> >
> > Here is the reference to my NumParams system:
> > On 10/23/2021 8:27 PM, olcott wrote:
> > [I finally completed my lexical analyzer generator (needed by my
> > halt decider)]
> > This system uses a DFA lexical analyzer to recognize
> > the pattern of function declarations. This pattern is
> > specified as 15 DFA states. The output is a C header
> > file that looks up the function name specified in the
> > COFF object file and returns its number of parameters.
> >
> >
>
> And where does this code get the source code of the program whose
> COMPILED form has been given to H?
>
> Or, is H now being given the source code as the representation?
>
> Remember, if you do that, then that source code needs to contain the
> FULL description of the program, which includes the code for H, and
> everything it uses, which includes your NumParams and the compiler
> you are going to put that code into.

Nope, H needs to be a black box so its implementation is unknown to
everyone but the creator of H. If H is a black box it can safely
detect recursion into it and signal an exception.

/Flibble

--
This message is a troll.

Re: Olcott wrong about infinite recursion [ simplest rebuttal of halting theorem ]

<upSdnfNv4q1S8RD8nZ2dnUU7-WXNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=23333&group=comp.theory#23333

 copy link   Newsgroups: comp.theory sci.logic sci.math comp.ai.philosophy
Followup: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Thu, 11 Nov 2021 13:19:43 -0600
Date: Thu, 11 Nov 2021 13:19:33 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.3.0
Subject: Re: Olcott wrong about infinite recursion [ simplest rebuttal of
halting theorem ]
Content-Language: en-US
Newsgroups: comp.theory,sci.logic,sci.math,comp.ai.philosophy
References: <20211110215316.0000221e@reddwarf.jmc>
<ApydnX6D6fN31RH8nZ2dnUU7-UXNnZ2d@giganews.com>
<PFZiJ.19745$cW6.10169@fx08.iad> <20211111175240.00000a3b@reddwarf.jmc>
From: NoO...@NoWhere.com (olcott)
Followup-To: comp.theory
In-Reply-To: <20211111175240.00000a3b@reddwarf.jmc>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <upSdnfNv4q1S8RD8nZ2dnUU7-WXNnZ2d@giganews.com>
Lines: 163
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-YnJ98I7AA26OoC0UsD64SaopzlN7aWoty0suLSmYh05xtst7JSssumgna3DNbGMpghyR0UyZxkv3G6h!QmXkt1CFaE/tl4C6QMFI2LzZFPnQPdE/zAMCu9WYUfQHGUA0WfSaSVEGB3kc6siA99bEG7i0qFUy!DA==
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 7300
 by: olcott - Thu, 11 Nov 2021 19:19 UTC

On 11/11/2021 11:52 AM, Mr Flibble wrote:
> On Wed, 10 Nov 2021 19:42:23 -0500
> Richard Damon <Richard@Damon-Family.org> wrote:
>
>> On 11/10/21 5:34 PM, olcott wrote:
>>> On 11/10/2021 3:53 PM, Mr Flibble wrote:
>>>> Olcott is barking up the wrong tree re infinite recursion: there
>>>> is only a need to detect a single recursive call into the halt
>>>> decider and signal an exception.
>>>
>>> Yes, I figured that out. That eliminates the need for static local
>>> data thus allowing the halt decider to be a pure function.
>>
>> Except that this logic is only correct if the function is being
>> executed under unconditional execution.
>>
>> If the 'simulation' is being run under condition that can/will
>> terminate its execution, then the detection of this recursion is NOT
>> proof that the execution will be non-halting.
>>
>> All you have show is that IF the decider would never abort its
>> 'simulation' then the program would be non-halting.
>>
>> Since it turns out that the decider DOES abort its 'simulation', the
>> assumptions that the analysis was done under are not in fact true, so
>> the analysis is invalid.
>>
>>
>>>
>>> https://en.wikipedia.org/wiki/Pure_function
>>
>> But Software Engineering 'Pure Function' is NOT the Compution Theory
>> 'Computation', so you need to be aware of the difference.
>>
>>>
>>> That is why I needed my source-code analyzer to provide the exact
>>> number of parameters to every function.
>>>
>>> As long as the currently executing function (H) is called again
>>> with the same parameters then we know that this call will be
>>> infinitely recursive unless this infinite recursion is aborted at
>>> some point.
>>
>> Right, it would be infinite if NEVER aborted, but it IS aborted, so
>> it is not infinite, and since the machine uses a copy of the decider,
>> that same fact applies to it being run as an indepent computation,
>> since the decider inside it does abort its internal simulation, it
>> return the answer that allows the actual computation to be finint.
>>
>>>
>>> When H aborts this call to itself made by P then P never reaches
>>> its final state. If H never aborts this call made by P then P never
>>> reaches its final state. This conclusively proves that H can abort
>>> this call to itself and report that its input never halts.
>>
>>
>> But it doensn't matter that H's PARTIAL simulation of P reached the
>> halting point. When we run the actual computation, or give this input
>> to a REAL pure simulator, it will Halt.
>>>
>>>
>>>
>>> Here is the reference to my NumParams system:
>>> On 10/23/2021 8:27 PM, olcott wrote:
>>> [I finally completed my lexical analyzer generator (needed by my
>>> halt decider)]
>>> This system uses a DFA lexical analyzer to recognize
>>> the pattern of function declarations. This pattern is
>>> specified as 15 DFA states. The output is a C header
>>> file that looks up the function name specified in the
>>> COFF object file and returns its number of parameters.
>>>
>>>
>>
>> And where does this code get the source code of the program whose
>> COMPILED form has been given to H?
>>
>> Or, is H now being given the source code as the representation?
>>
>> Remember, if you do that, then that source code needs to contain the
>> FULL description of the program, which includes the code for H, and
>> everything it uses, which includes your NumParams and the compiler
>> you are going to put that code into.
>
> Nope, H needs to be a black box so its implementation is unknown to
> everyone but the creator of H. If H is a black box it can safely
> detect recursion into it and signal an exception.

That won't work because someone could write the same H as a whitebox.

Here is my current enormously simplified proof:
Does the call from P() to H() specify infinite recursion?

#define ptr uintptr_t

void P(ptr x)
{ H(x, x);
}

int H(ptr x, ptr y)
{ ((void(*)(ptr))x)(y);
return 1;
}

int main()
{ H((ptr)P, (ptr)P);
return 0;
}

Yes it does.

_P()
[00001a5e](01) 55 push ebp
[00001a5f](02) 8bec mov ebp,esp
[00001a61](03) 8b4508 mov eax,[ebp+08]
[00001a64](01) 50 push eax // push P
[00001a65](03) 8b4d08 mov ecx,[ebp+08]
[00001a68](01) 51 push ecx // push P
[00001a69](05) e810000000 call 00001a7e // call H
[00001a6e](03) 83c408 add esp,+08
[00001a71](01) 5d pop ebp
[00001a72](01) c3 ret
Size in bytes:(0021) [00001a72]

Now we switch H executing its input to H simulating its input. H
simulates the x86 machine language of its input and sees that its
simulated P is calling H with the same parameters that H was called
with. On this basis H aborts its simulation of P and correctly reports
that P would never reach its final state at 1a72. Because H and P are
both pure functions we know that H(P,P)==0 is computable.

(a) P only halts if it reaches its final state at 1a72.
(b) If H does not abort its simulation of P then P never reaches its
final state at 1a72.
(c) If H aborts its simulation of P then P never reaches its final state
as 1a72.
(d) Because P never halts in all possible cases H(P,P)==0 is always
correct.

The fact that there are no errors in (a)(b)(c) and (d) is a necessary
consequence of (a)(b)(c) conclusively proves that (d) is correct.

Halting problem undecidability and infinitely nested simulation (V2)

https://www.researchgate.net/publication/356105750_Halting_problem_undecidability_and_infinitely_nested_simulation_V2

>
> /Flibble
>
> --
> This message is a troll.
>

--
Copyright 2021 Pete Olcott

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

Re: Olcott wrong about infinite recursion [ simplest rebuttal of halting theorem ]

<rdejJ.20399$SW5.15061@fx45.iad>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=23337&group=comp.theory#23337

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!feeder1.feed.usenet.farm!feed.usenet.farm!peer01.ams4!peer.am4.highwinds-media.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx45.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.3.0
Subject: Re: Olcott wrong about infinite recursion [ simplest rebuttal of
halting theorem ]
Content-Language: en-US
Newsgroups: comp.theory
References: <20211110215316.0000221e@reddwarf.jmc>
<ApydnX6D6fN31RH8nZ2dnUU7-UXNnZ2d@giganews.com>
<PFZiJ.19745$cW6.10169@fx08.iad> <20211111175240.00000a3b@reddwarf.jmc>
<upSdnfNv4q1S8RD8nZ2dnUU7-WXNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <upSdnfNv4q1S8RD8nZ2dnUU7-WXNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 177
Message-ID: <rdejJ.20399$SW5.15061@fx45.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Thu, 11 Nov 2021 14:32:34 -0500
X-Received-Bytes: 8302
 by: Richard Damon - Thu, 11 Nov 2021 19:32 UTC

On 11/11/21 2:19 PM, olcott wrote:
> On 11/11/2021 11:52 AM, Mr Flibble wrote:
>> On Wed, 10 Nov 2021 19:42:23 -0500
>> Richard Damon <Richard@Damon-Family.org> wrote:
>>
>>> On 11/10/21 5:34 PM, olcott wrote:
>>>> On 11/10/2021 3:53 PM, Mr Flibble wrote:
>>>>> Olcott is barking up the wrong tree re infinite recursion: there
>>>>> is only a need to detect a single recursive call into the halt
>>>>> decider and signal an exception.
>>>>
>>>> Yes, I figured that out. That eliminates the need for static local
>>>> data thus allowing the halt decider to be a pure function.
>>>
>>> Except that this logic is only correct if the function is being
>>> executed under unconditional execution.
>>>
>>> If the 'simulation' is being run under condition that can/will
>>> terminate its execution, then the detection of this recursion is NOT
>>> proof that the execution will be non-halting.
>>>
>>> All you have show is that IF the decider would never abort its
>>> 'simulation' then the program would be non-halting.
>>>
>>> Since it turns out that the decider DOES abort its 'simulation', the
>>> assumptions that the analysis was done under are not in fact true, so
>>> the analysis is invalid.
>>>
>>>
>>>>
>>>> https://en.wikipedia.org/wiki/Pure_function
>>>
>>> But Software Engineering 'Pure Function' is NOT the Compution Theory
>>> 'Computation', so you need to be aware of the difference.
>>>
>>>>
>>>> That is why I needed my source-code analyzer to provide the exact
>>>> number of parameters to every function.
>>>>
>>>> As long as the currently executing function (H) is called again
>>>> with the same parameters then we know that this call will be
>>>> infinitely recursive unless this infinite recursion is aborted at
>>>> some point.
>>>
>>> Right, it would be infinite if NEVER aborted, but it IS aborted, so
>>> it is not infinite, and since the machine uses a copy of the decider,
>>> that same fact applies to it being run as an indepent computation,
>>> since the decider inside it does abort its internal simulation, it
>>> return the answer that allows the actual computation to be finint.
>>>
>>>>
>>>> When H aborts this call to itself made by P then P never reaches
>>>> its final state. If H never aborts this call made by P then P never
>>>> reaches its final state. This conclusively proves that H can abort
>>>> this call to itself and report that its input never halts.
>>>
>>>
>>> But it doensn't matter that H's PARTIAL simulation of P reached the
>>> halting point. When we run the actual computation, or give this input
>>> to a REAL pure simulator, it will Halt.
>>>>
>>>>
>>>>
>>>> Here is the reference to my NumParams system:
>>>> On 10/23/2021 8:27 PM, olcott wrote:
>>>> [I finally completed my lexical analyzer generator (needed by my
>>>> halt decider)]
>>>> This system uses a DFA lexical analyzer to recognize
>>>> the pattern of function declarations. This pattern is
>>>> specified as 15 DFA states. The output is a C header
>>>> file that looks up the function name specified in the
>>>> COFF object file and returns its number of parameters.
>>>>
>>>
>>> And where does this code get the source code of the program whose
>>> COMPILED form has been given to H?
>>>
>>> Or, is H now being given the source code as the representation?
>>>
>>> Remember, if you do that, then that source code needs to contain the
>>> FULL description of the program, which includes the code for H, and
>>> everything it uses, which includes your NumParams and the compiler
>>> you are going to put that code into.
>>
>> Nope, H needs to be a black box so its implementation is unknown to
>> everyone but the creator of H.  If H is a black box it can safely
>> detect recursion into it and signal an exception.
>
> That won't work because someone could write the same H as a whitebox.
>
> Here is my current enormously simplified proof:
> Does the call from P() to H() specify infinite recursion?
>
> #define ptr uintptr_t
>
> void P(ptr x)
> {
>   H(x, x);
> }
>
> int H(ptr x, ptr y)
> {
>   ((void(*)(ptr))x)(y);
>   return 1;
> }
>
> int main()
> {
>   H((ptr)P, (ptr)P);
>   return 0;
> }
>
> Yes it does.
>
> _P()
> [00001a5e](01)  55              push ebp
> [00001a5f](02)  8bec            mov ebp,esp
> [00001a61](03)  8b4508          mov eax,[ebp+08]
> [00001a64](01)  50              push eax        // push P
> [00001a65](03)  8b4d08          mov ecx,[ebp+08]
> [00001a68](01)  51              push ecx        // push P
> [00001a69](05)  e810000000      call 00001a7e   // call H
> [00001a6e](03)  83c408          add esp,+08
> [00001a71](01)  5d              pop ebp
> [00001a72](01)  c3              ret
> Size in bytes:(0021) [00001a72]
>
> Now we switch H executing its input to H simulating its input. H
> simulates the x86 machine language of its input and sees that its
> simulated P is calling H with the same parameters that H was called
> with. On this basis H aborts its simulation of P and correctly reports
> that P would never reach its final state at 1a72. Because H and P are
> both pure functions we know that H(P,P)==0 is computable.
>
> (a) P only halts if it reaches its final state at 1a72.
> (b) If H does not abort its simulation of P then P never reaches its
> final state at 1a72.
> (c) If H aborts its simulation of P then P never reaches its final state
> as 1a72.
> (d) Because P never halts in all possible cases H(P,P)==0 is always
> correct.
>
> The fact that there are no errors in (a)(b)(c) and (d) is a necessary
> consequence of (a)(b)(c) conclusively proves that (d) is correct.
>
> Halting problem undecidability and infinitely nested simulation (V2)
>
> https://www.researchgate.net/publication/356105750_Halting_problem_undecidability_and_infinitely_nested_simulation_V2
>
>

Ye, for THAT H, you do have infinite recursion and THAT P is
non-halting, but THAT H never returns 0 for H(P,P) so it isn't a correct
halt decider.

The problem is that since P's behavior is affected by the definition of
H, you can't change the H to give you that answer and still be able to
use what you just proved.

You ALWAYS end up in your logic with a false assumption and thus an
invalid proof.

You need to keep your various Hs and Ps straight, which you don't seem
capable of doing.

Part of the problem seems to be that you think you are just trying to
solve the halting question of the source code C function H, but that is
NOT the task you actually need to be doing.

The Halting Problem is about COMPUTATIONS, which are more closely
associated with FULL PROGRAMS, not just functions.

You should have seen this when you looked at the definitions of Pure
Functions, because not only does the code for the particular function
called need to meet that purity requirements, but so does every function
that it calls (and down the call chain).

Re: Olcott wrong about infinite recursion [ simplest rebuttal of halting theorem ]

<20211111195814.00001bcd@reddwarf.jmc>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=23340&group=comp.theory#23340

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!4.us.feeder.erje.net!2.eu.feeder.erje.net!feeder.erje.net!news.uzoreto.com!newsreader4.netcologne.de!news.netcologne.de!peer03.ams1!peer.ams1.xlned.com!news.xlned.com!peer01.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx05.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc (Mr Flibble)
Newsgroups: comp.theory
Subject: Re: Olcott wrong about infinite recursion [ simplest rebuttal of
halting theorem ]
Message-ID: <20211111195814.00001bcd@reddwarf.jmc>
References: <20211110215316.0000221e@reddwarf.jmc>
<ApydnX6D6fN31RH8nZ2dnUU7-UXNnZ2d@giganews.com>
<PFZiJ.19745$cW6.10169@fx08.iad>
<20211111175240.00000a3b@reddwarf.jmc>
<upSdnfNv4q1S8RD8nZ2dnUU7-WXNnZ2d@giganews.com>
Organization: Jupiter Mining Corp
X-Newsreader: Claws Mail 3.17.8 (GTK+ 2.24.33; x86_64-w64-mingw32)
MIME-Version: 1.0
Content-Type: text/plain; charset=US-ASCII
Content-Transfer-Encoding: 7bit
Lines: 104
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Thu, 11 Nov 2021 19:58:13 UTC
Date: Thu, 11 Nov 2021 19:58:14 +0000
X-Received-Bytes: 5262
 by: Mr Flibble - Thu, 11 Nov 2021 19:58 UTC

On Thu, 11 Nov 2021 13:19:33 -0600
olcott <NoOne@NoWhere.com> wrote:

> On 11/11/2021 11:52 AM, Mr Flibble wrote:
> > On Wed, 10 Nov 2021 19:42:23 -0500
> > Richard Damon <Richard@Damon-Family.org> wrote:
> >
> >> On 11/10/21 5:34 PM, olcott wrote:
> >>> On 11/10/2021 3:53 PM, Mr Flibble wrote:
> >>>> Olcott is barking up the wrong tree re infinite recursion: there
> >>>> is only a need to detect a single recursive call into the halt
> >>>> decider and signal an exception.
> >>>
> >>> Yes, I figured that out. That eliminates the need for static local
> >>> data thus allowing the halt decider to be a pure function.
> >>
> >> Except that this logic is only correct if the function is being
> >> executed under unconditional execution.
> >>
> >> If the 'simulation' is being run under condition that can/will
> >> terminate its execution, then the detection of this recursion is
> >> NOT proof that the execution will be non-halting.
> >>
> >> All you have show is that IF the decider would never abort its
> >> 'simulation' then the program would be non-halting.
> >>
> >> Since it turns out that the decider DOES abort its 'simulation',
> >> the assumptions that the analysis was done under are not in fact
> >> true, so the analysis is invalid.
> >>
> >>
> >>>
> >>> https://en.wikipedia.org/wiki/Pure_function
> >>
> >> But Software Engineering 'Pure Function' is NOT the Compution
> >> Theory 'Computation', so you need to be aware of the difference.
> >>
> >>>
> >>> That is why I needed my source-code analyzer to provide the exact
> >>> number of parameters to every function.
> >>>
> >>> As long as the currently executing function (H) is called again
> >>> with the same parameters then we know that this call will be
> >>> infinitely recursive unless this infinite recursion is aborted at
> >>> some point.
> >>
> >> Right, it would be infinite if NEVER aborted, but it IS aborted, so
> >> it is not infinite, and since the machine uses a copy of the
> >> decider, that same fact applies to it being run as an indepent
> >> computation, since the decider inside it does abort its internal
> >> simulation, it return the answer that allows the actual
> >> computation to be finint.
> >>>
> >>> When H aborts this call to itself made by P then P never reaches
> >>> its final state. If H never aborts this call made by P then P
> >>> never reaches its final state. This conclusively proves that H
> >>> can abort this call to itself and report that its input never
> >>> halts.
> >>
> >>
> >> But it doensn't matter that H's PARTIAL simulation of P reached the
> >> halting point. When we run the actual computation, or give this
> >> input to a REAL pure simulator, it will Halt.
> >>>
> >>>
> >>>
> >>> Here is the reference to my NumParams system:
> >>> On 10/23/2021 8:27 PM, olcott wrote:
> >>> [I finally completed my lexical analyzer generator (needed by my
> >>> halt decider)]
> >>> This system uses a DFA lexical analyzer to recognize
> >>> the pattern of function declarations. This pattern is
> >>> specified as 15 DFA states. The output is a C header
> >>> file that looks up the function name specified in the
> >>> COFF object file and returns its number of parameters.
> >>>
> >>>
> >>
> >> And where does this code get the source code of the program whose
> >> COMPILED form has been given to H?
> >>
> >> Or, is H now being given the source code as the representation?
> >>
> >> Remember, if you do that, then that source code needs to contain
> >> the FULL description of the program, which includes the code for
> >> H, and everything it uses, which includes your NumParams and the
> >> compiler you are going to put that code into.
> >
> > Nope, H needs to be a black box so its implementation is unknown to
> > everyone but the creator of H. If H is a black box it can safely
> > detect recursion into it and signal an exception.
>
> That won't work because someone could write the same H as a whitebox.

They could only do that by accident so if the probability of blindly
replicating the black box is sufficiently low we can discount it (just
as we can discount cracking a 512-bit encryption key with a
classical computer).

/Flibble

--
This message is a troll.

Re: Olcott wrong about infinite recursion [ simplest rebuttal of halting theorem ]

<tIqdncrf0fM86xD8nZ2dnUU7-XednZ2d@giganews.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=23342&group=comp.theory#23342

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Thu, 11 Nov 2021 14:01:36 -0600
Date: Thu, 11 Nov 2021 14:01:35 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.3.0
Subject: Re: Olcott wrong about infinite recursion [ simplest rebuttal of
halting theorem ]
Content-Language: en-US
Newsgroups: comp.theory
References: <20211110215316.0000221e@reddwarf.jmc>
<ApydnX6D6fN31RH8nZ2dnUU7-UXNnZ2d@giganews.com>
<PFZiJ.19745$cW6.10169@fx08.iad> <20211111175240.00000a3b@reddwarf.jmc>
<upSdnfNv4q1S8RD8nZ2dnUU7-WXNnZ2d@giganews.com>
<rdejJ.20399$SW5.15061@fx45.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <rdejJ.20399$SW5.15061@fx45.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <tIqdncrf0fM86xD8nZ2dnUU7-XednZ2d@giganews.com>
Lines: 170
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-xEyCsJVf9jWyi04C9S5OpzDiSlrMsO8HvcK7l2BQNRo/co8w3sUjjGTHCTsz7Olr2NSZ0s/SvKD+waO!5XpVKPO7O4ujmOGEGrIN887xXvaSXm4siYMTLfNOZKXgCLAgoX0pSPYX/SyvB3aBzvEaShlQvy0U!BQ==
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 8174
 by: olcott - Thu, 11 Nov 2021 20:01 UTC

On 11/11/2021 1:32 PM, Richard Damon wrote:
>
> On 11/11/21 2:19 PM, olcott wrote:
>> On 11/11/2021 11:52 AM, Mr Flibble wrote:
>>> On Wed, 10 Nov 2021 19:42:23 -0500
>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>
>>>> On 11/10/21 5:34 PM, olcott wrote:
>>>>> On 11/10/2021 3:53 PM, Mr Flibble wrote:
>>>>>> Olcott is barking up the wrong tree re infinite recursion: there
>>>>>> is only a need to detect a single recursive call into the halt
>>>>>> decider and signal an exception.
>>>>>
>>>>> Yes, I figured that out. That eliminates the need for static local
>>>>> data thus allowing the halt decider to be a pure function.
>>>>
>>>> Except that this logic is only correct if the function is being
>>>> executed under unconditional execution.
>>>>
>>>> If the 'simulation' is being run under condition that can/will
>>>> terminate its execution, then the detection of this recursion is NOT
>>>> proof that the execution will be non-halting.
>>>>
>>>> All you have show is that IF the decider would never abort its
>>>> 'simulation' then the program would be non-halting.
>>>>
>>>> Since it turns out that the decider DOES abort its 'simulation', the
>>>> assumptions that the analysis was done under are not in fact true, so
>>>> the analysis is invalid.
>>>>
>>>>
>>>>>
>>>>> https://en.wikipedia.org/wiki/Pure_function
>>>>
>>>> But Software Engineering 'Pure Function' is NOT the Compution Theory
>>>> 'Computation', so you need to be aware of the difference.
>>>>
>>>>>
>>>>> That is why I needed my source-code analyzer to provide the exact
>>>>> number of parameters to every function.
>>>>>
>>>>> As long as the currently executing function (H) is called again
>>>>> with the same parameters then we know that this call will be
>>>>> infinitely recursive unless this infinite recursion is aborted at
>>>>> some point.
>>>>
>>>> Right, it would be infinite if NEVER aborted, but it IS aborted, so
>>>> it is not infinite, and since the machine uses a copy of the decider,
>>>> that same fact applies to it being run as an indepent computation,
>>>> since the decider inside it does abort its internal simulation, it
>>>> return the answer that allows the actual computation to be finint.
>>>>
>>>>>
>>>>> When H aborts this call to itself made by P then P never reaches
>>>>> its final state. If H never aborts this call made by P then P never
>>>>> reaches its final state. This conclusively proves that H can abort
>>>>> this call to itself and report that its input never halts.
>>>>
>>>>
>>>> But it doensn't matter that H's PARTIAL simulation of P reached the
>>>> halting point. When we run the actual computation, or give this input
>>>> to a REAL pure simulator, it will Halt.
>>>>>
>>>>>
>>>>>
>>>>> Here is the reference to my NumParams system:
>>>>> On 10/23/2021 8:27 PM, olcott wrote:
>>>>> [I finally completed my lexical analyzer generator (needed by my
>>>>> halt decider)]
>>>>> This system uses a DFA lexical analyzer to recognize
>>>>> the pattern of function declarations. This pattern is
>>>>> specified as 15 DFA states. The output is a C header
>>>>> file that looks up the function name specified in the
>>>>> COFF object file and returns its number of parameters.
>>>>>
>>>>
>>>> And where does this code get the source code of the program whose
>>>> COMPILED form has been given to H?
>>>>
>>>> Or, is H now being given the source code as the representation?
>>>>
>>>> Remember, if you do that, then that source code needs to contain the
>>>> FULL description of the program, which includes the code for H, and
>>>> everything it uses, which includes your NumParams and the compiler
>>>> you are going to put that code into.
>>>
>>> Nope, H needs to be a black box so its implementation is unknown to
>>> everyone but the creator of H.  If H is a black box it can safely
>>> detect recursion into it and signal an exception.
>>
>> That won't work because someone could write the same H as a whitebox.
>>
>> Here is my current enormously simplified proof:
>> Does the call from P() to H() specify infinite recursion?
>>
>> #define ptr uintptr_t
>>
>> void P(ptr x)
>> {
>>    H(x, x);
>> }
>>
>> int H(ptr x, ptr y)
>> {
>>    ((void(*)(ptr))x)(y);
>>    return 1;
>> }
>>
>> int main()
>> {
>>    H((ptr)P, (ptr)P);
>>    return 0;
>> }
>>
>> Yes it does.
>>
>> _P()
>> [00001a5e](01)  55              push ebp
>> [00001a5f](02)  8bec            mov ebp,esp
>> [00001a61](03)  8b4508          mov eax,[ebp+08]
>> [00001a64](01)  50              push eax        // push P
>> [00001a65](03)  8b4d08          mov ecx,[ebp+08]
>> [00001a68](01)  51              push ecx        // push P
>> [00001a69](05)  e810000000      call 00001a7e   // call H
>> [00001a6e](03)  83c408          add esp,+08
>> [00001a71](01)  5d              pop ebp
>> [00001a72](01)  c3              ret
>> Size in bytes:(0021) [00001a72]

YOU TOTALLY IGNORED ALL OF THESE NEXT WORDS
YOU TOTALLY IGNORED ALL OF THESE NEXT WORDS
YOU TOTALLY IGNORED ALL OF THESE NEXT WORDS
YOU TOTALLY IGNORED ALL OF THESE NEXT WORDS

>> Now we switch H executing its input to H simulating its input. H
>> simulates the x86 machine language of its input and sees that its
>> simulated P is calling H with the same parameters that H was called
>> with. On this basis H aborts its simulation of P and correctly reports
>> that P would never reach its final state at 1a72. Because H and P are
>> both pure functions we know that H(P,P)==0 is computable.
>>
>> (a) P only halts if it reaches its final state at 1a72.
>> (b) If H does not abort its simulation of P then P never reaches its
>> final state at 1a72.
>> (c) If H aborts its simulation of P then P never reaches its final
>> state as 1a72.
>> (d) Because P never halts in all possible cases H(P,P)==0 is always
>> correct.
>>
>> The fact that there are no errors in (a)(b)(c) and (d) is a necessary
>> consequence of (a)(b)(c) conclusively proves that (d) is correct.
>>
>> Halting problem undecidability and infinitely nested simulation (V2)
>>
>> https://www.researchgate.net/publication/356105750_Halting_problem_undecidability_and_infinitely_nested_simulation_V2
>>
>>
>
> Ye, for THAT H, you do have infinite recursion and THAT P is
> non-halting, but THAT H never returns 0 for H(P,P) so it isn't a correct
> halt decider.
>

--
Copyright 2021 Pete Olcott

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

Re: Olcott wrong about infinite recursion [ simplest rebuttal of halting theorem ]

<N_ydnYUGyNtE5BD8nZ2dnUU7-RPNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=23344&group=comp.theory#23344

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Thu, 11 Nov 2021 14:15:21 -0600
Date: Thu, 11 Nov 2021 14:15:19 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.3.0
Subject: Re: Olcott wrong about infinite recursion [ simplest rebuttal of
halting theorem ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <20211110215316.0000221e@reddwarf.jmc>
<ApydnX6D6fN31RH8nZ2dnUU7-UXNnZ2d@giganews.com>
<PFZiJ.19745$cW6.10169@fx08.iad> <20211111175240.00000a3b@reddwarf.jmc>
<upSdnfNv4q1S8RD8nZ2dnUU7-WXNnZ2d@giganews.com>
<20211111195814.00001bcd@reddwarf.jmc>
From: NoO...@NoWhere.com (olcott)
Followup-To: comp.theory
In-Reply-To: <20211111195814.00001bcd@reddwarf.jmc>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <N_ydnYUGyNtE5BD8nZ2dnUU7-RPNnZ2d@giganews.com>
Lines: 185
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-oiNzajsMK51S7yPQZPtvL79H9TBmyvTKKDFIvdYUVq/4s73izOxLXvT3p972oBiKueMKBy9QmoO38Iy!m4d5i5ZQgfojnCMrL7i5yNwN8kUpW7/jFlv1Ecb8L55SUlmffh3T8BFoX8f0xlcSvGNT0SHjCs8P!bw==
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 7890
 by: olcott - Thu, 11 Nov 2021 20:15 UTC

On 11/11/2021 1:58 PM, Mr Flibble wrote:
> On Thu, 11 Nov 2021 13:19:33 -0600
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 11/11/2021 11:52 AM, Mr Flibble wrote:
>>> On Wed, 10 Nov 2021 19:42:23 -0500
>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>
>>>> On 11/10/21 5:34 PM, olcott wrote:
>>>>> On 11/10/2021 3:53 PM, Mr Flibble wrote:
>>>>>> Olcott is barking up the wrong tree re infinite recursion: there
>>>>>> is only a need to detect a single recursive call into the halt
>>>>>> decider and signal an exception.
>>>>>
>>>>> Yes, I figured that out. That eliminates the need for static local
>>>>> data thus allowing the halt decider to be a pure function.
>>>>
>>>> Except that this logic is only correct if the function is being
>>>> executed under unconditional execution.
>>>>
>>>> If the 'simulation' is being run under condition that can/will
>>>> terminate its execution, then the detection of this recursion is
>>>> NOT proof that the execution will be non-halting.
>>>>
>>>> All you have show is that IF the decider would never abort its
>>>> 'simulation' then the program would be non-halting.
>>>>
>>>> Since it turns out that the decider DOES abort its 'simulation',
>>>> the assumptions that the analysis was done under are not in fact
>>>> true, so the analysis is invalid.
>>>>
>>>>
>>>>>
>>>>> https://en.wikipedia.org/wiki/Pure_function
>>>>
>>>> But Software Engineering 'Pure Function' is NOT the Compution
>>>> Theory 'Computation', so you need to be aware of the difference.
>>>>
>>>>>
>>>>> That is why I needed my source-code analyzer to provide the exact
>>>>> number of parameters to every function.
>>>>>
>>>>> As long as the currently executing function (H) is called again
>>>>> with the same parameters then we know that this call will be
>>>>> infinitely recursive unless this infinite recursion is aborted at
>>>>> some point.
>>>>
>>>> Right, it would be infinite if NEVER aborted, but it IS aborted, so
>>>> it is not infinite, and since the machine uses a copy of the
>>>> decider, that same fact applies to it being run as an indepent
>>>> computation, since the decider inside it does abort its internal
>>>> simulation, it return the answer that allows the actual
>>>> computation to be finint.
>>>>>
>>>>> When H aborts this call to itself made by P then P never reaches
>>>>> its final state. If H never aborts this call made by P then P
>>>>> never reaches its final state. This conclusively proves that H
>>>>> can abort this call to itself and report that its input never
>>>>> halts.
>>>>
>>>>
>>>> But it doensn't matter that H's PARTIAL simulation of P reached the
>>>> halting point. When we run the actual computation, or give this
>>>> input to a REAL pure simulator, it will Halt.
>>>>>
>>>>>
>>>>>
>>>>> Here is the reference to my NumParams system:
>>>>> On 10/23/2021 8:27 PM, olcott wrote:
>>>>> [I finally completed my lexical analyzer generator (needed by my
>>>>> halt decider)]
>>>>> This system uses a DFA lexical analyzer to recognize
>>>>> the pattern of function declarations. This pattern is
>>>>> specified as 15 DFA states. The output is a C header
>>>>> file that looks up the function name specified in the
>>>>> COFF object file and returns its number of parameters.
>>>>>
>>>>>
>>>>
>>>> And where does this code get the source code of the program whose
>>>> COMPILED form has been given to H?
>>>>
>>>> Or, is H now being given the source code as the representation?
>>>>
>>>> Remember, if you do that, then that source code needs to contain
>>>> the FULL description of the program, which includes the code for
>>>> H, and everything it uses, which includes your NumParams and the
>>>> compiler you are going to put that code into.
>>>
>>> Nope, H needs to be a black box so its implementation is unknown to
>>> everyone but the creator of H. If H is a black box it can safely
>>> detect recursion into it and signal an exception.
>>
>> That won't work because someone could write the same H as a whitebox.
>
> They could only do that by accident so if the probability of blindly
> replicating the black box is sufficiently low we can discount it (just
> as we can discount cracking a 512-bit encryption key with a
> classical computer).
>
> /Flibble
>
> --
> This message is a troll.
>

I have already spent many hundreds of hours going all through that path
decades ago. As long as there is one input that can fool a halt decider
the halting problem cannot be solved.

The machine code of this input is no longer an input that cannot be
correctly decided. I enormously simplified the proof of this.

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

The P show below has been simplified so that it only has the essence of
the infinitely recursive nature of the above P.

#include <stdint.h>
#define ptr uintptr_t

int H(ptr x, ptr y)
{ ((void(*)(ptr))x)(y);
return 1;
}

void P(ptr x)
{ H(x, x);
}

int main()
{ H((ptr)P, (ptr)P);
return 0;
}

_P()
[00001a7e](01) 55 push ebp
[00001a7f](02) 8bec mov ebp,esp
[00001a81](03) 8b4508 mov eax,[ebp+08]
[00001a84](01) 50 push eax
[00001a85](03) 8b4d08 mov ecx,[ebp+08]
[00001a88](01) 51 push ecx
[00001a89](05) e810000000 call 00001a9e
[00001a8e](03) 83c408 add esp,+08
[00001a91](01) 5d pop ebp
[00001a92](01) c3 ret
Size in bytes:(0021) [00001a92]

(a) P only halts if it reaches its final state at 1a72.

(b) If H does not abort its simulation of P then P never reaches its
final state at 1a72.

(c) If H aborts its simulation of P then P never reaches its final state
as 1a72.

(d) Because P never halts in all possible cases H(P,P)==0 is always
correct.

The fact that there are no errors in (a)(b)(c) and (d) is a necessary
consequence of (a)(b)(c) conclusively proves that (d) is correct.

This same proof applies to this more complex P, yet is a has more
details making it more difficult to understand:

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

--
Copyright 2021 Pete Olcott

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

Re: Olcott wrong about infinite recursion [ simplest rebuttal of halting theorem ]

<NZejJ.21674$SW5.667@fx45.iad>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=23347&group=comp.theory#23347

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!news.uzoreto.com!newsfeed.xs4all.nl!newsfeed9.news.xs4all.nl!feeder5.feed.usenet.farm!feeder1.feed.usenet.farm!feed.usenet.farm!peer01.ams4!peer.am4.highwinds-media.com!peer01.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx45.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.3.0
Subject: Re: Olcott wrong about infinite recursion [ simplest rebuttal of
halting theorem ]
Content-Language: en-US
Newsgroups: comp.theory
References: <20211110215316.0000221e@reddwarf.jmc>
<ApydnX6D6fN31RH8nZ2dnUU7-UXNnZ2d@giganews.com>
<PFZiJ.19745$cW6.10169@fx08.iad> <20211111175240.00000a3b@reddwarf.jmc>
<upSdnfNv4q1S8RD8nZ2dnUU7-WXNnZ2d@giganews.com>
<rdejJ.20399$SW5.15061@fx45.iad>
<tIqdncrf0fM86xD8nZ2dnUU7-XednZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <tIqdncrf0fM86xD8nZ2dnUU7-XednZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 178
Message-ID: <NZejJ.21674$SW5.667@fx45.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Thu, 11 Nov 2021 15:24:13 -0500
X-Received-Bytes: 8371
 by: Richard Damon - Thu, 11 Nov 2021 20:24 UTC

On 11/11/21 3:01 PM, olcott wrote:
> On 11/11/2021 1:32 PM, Richard Damon wrote:
>>
>> On 11/11/21 2:19 PM, olcott wrote:
>>> On 11/11/2021 11:52 AM, Mr Flibble wrote:
>>>> On Wed, 10 Nov 2021 19:42:23 -0500
>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>
>>>>> On 11/10/21 5:34 PM, olcott wrote:
>>>>>> On 11/10/2021 3:53 PM, Mr Flibble wrote:
>>>>>>> Olcott is barking up the wrong tree re infinite recursion: there
>>>>>>> is only a need to detect a single recursive call into the halt
>>>>>>> decider and signal an exception.
>>>>>>
>>>>>> Yes, I figured that out. That eliminates the need for static local
>>>>>> data thus allowing the halt decider to be a pure function.
>>>>>
>>>>> Except that this logic is only correct if the function is being
>>>>> executed under unconditional execution.
>>>>>
>>>>> If the 'simulation' is being run under condition that can/will
>>>>> terminate its execution, then the detection of this recursion is NOT
>>>>> proof that the execution will be non-halting.
>>>>>
>>>>> All you have show is that IF the decider would never abort its
>>>>> 'simulation' then the program would be non-halting.
>>>>>
>>>>> Since it turns out that the decider DOES abort its 'simulation', the
>>>>> assumptions that the analysis was done under are not in fact true, so
>>>>> the analysis is invalid.
>>>>>
>>>>>
>>>>>>
>>>>>> https://en.wikipedia.org/wiki/Pure_function
>>>>>
>>>>> But Software Engineering 'Pure Function' is NOT the Compution Theory
>>>>> 'Computation', so you need to be aware of the difference.
>>>>>
>>>>>>
>>>>>> That is why I needed my source-code analyzer to provide the exact
>>>>>> number of parameters to every function.
>>>>>>
>>>>>> As long as the currently executing function (H) is called again
>>>>>> with the same parameters then we know that this call will be
>>>>>> infinitely recursive unless this infinite recursion is aborted at
>>>>>> some point.
>>>>>
>>>>> Right, it would be infinite if NEVER aborted, but it IS aborted, so
>>>>> it is not infinite, and since the machine uses a copy of the decider,
>>>>> that same fact applies to it being run as an indepent computation,
>>>>> since the decider inside it does abort its internal simulation, it
>>>>> return the answer that allows the actual computation to be finint.
>>>>>
>>>>>>
>>>>>> When H aborts this call to itself made by P then P never reaches
>>>>>> its final state. If H never aborts this call made by P then P never
>>>>>> reaches its final state. This conclusively proves that H can abort
>>>>>> this call to itself and report that its input never halts.
>>>>>
>>>>>
>>>>> But it doensn't matter that H's PARTIAL simulation of P reached the
>>>>> halting point. When we run the actual computation, or give this input
>>>>> to a REAL pure simulator, it will Halt.
>>>>>>
>>>>>>
>>>>>>
>>>>>> Here is the reference to my NumParams system:
>>>>>> On 10/23/2021 8:27 PM, olcott wrote:
>>>>>> [I finally completed my lexical analyzer generator (needed by my
>>>>>> halt decider)]
>>>>>> This system uses a DFA lexical analyzer to recognize
>>>>>> the pattern of function declarations. This pattern is
>>>>>> specified as 15 DFA states. The output is a C header
>>>>>> file that looks up the function name specified in the
>>>>>> COFF object file and returns its number of parameters.
>>>>>>
>>>>>
>>>>> And where does this code get the source code of the program whose
>>>>> COMPILED form has been given to H?
>>>>>
>>>>> Or, is H now being given the source code as the representation?
>>>>>
>>>>> Remember, if you do that, then that source code needs to contain the
>>>>> FULL description of the program, which includes the code for H, and
>>>>> everything it uses, which includes your NumParams and the compiler
>>>>> you are going to put that code into.
>>>>
>>>> Nope, H needs to be a black box so its implementation is unknown to
>>>> everyone but the creator of H.  If H is a black box it can safely
>>>> detect recursion into it and signal an exception.
>>>
>>> That won't work because someone could write the same H as a whitebox.
>>>
>>> Here is my current enormously simplified proof:
>>> Does the call from P() to H() specify infinite recursion?
>>>
>>> #define ptr uintptr_t
>>>
>>> void P(ptr x)
>>> {
>>>    H(x, x);
>>> }
>>>
>>> int H(ptr x, ptr y)
>>> {
>>>    ((void(*)(ptr))x)(y);
>>>    return 1;
>>> }
>>>
>>> int main()
>>> {
>>>    H((ptr)P, (ptr)P);
>>>    return 0;
>>> }
>>>
>>> Yes it does.
>>>
>>> _P()
>>> [00001a5e](01)  55              push ebp
>>> [00001a5f](02)  8bec            mov ebp,esp
>>> [00001a61](03)  8b4508          mov eax,[ebp+08]
>>> [00001a64](01)  50              push eax        // push P
>>> [00001a65](03)  8b4d08          mov ecx,[ebp+08]
>>> [00001a68](01)  51              push ecx        // push P
>>> [00001a69](05)  e810000000      call 00001a7e   // call H
>>> [00001a6e](03)  83c408          add esp,+08
>>> [00001a71](01)  5d              pop ebp
>>> [00001a72](01)  c3              ret
>>> Size in bytes:(0021) [00001a72]
>
>
> YOU TOTALLY IGNORED ALL OF THESE NEXT WORDS
> YOU TOTALLY IGNORED ALL OF THESE NEXT WORDS
> YOU TOTALLY IGNORED ALL OF THESE NEXT WORDS
> YOU TOTALLY IGNORED ALL OF THESE NEXT WORDS

You can not use the 'proof' for the H that doesn't abort for the H that
does, they are different Hs and create different Ps.

See other post for a full explantion, you aren't worth the time to
repeat it, I have more important things to do.

Is seems you don't.

>
>>> Now we switch H executing its input to H simulating its input. H
>>> simulates the x86 machine language of its input and sees that its
>>> simulated P is calling H with the same parameters that H was called
>>> with. On this basis H aborts its simulation of P and correctly
>>> reports that P would never reach its final state at 1a72. Because H
>>> and P are both pure functions we know that H(P,P)==0 is computable.
>>>
>>> (a) P only halts if it reaches its final state at 1a72.
>>> (b) If H does not abort its simulation of P then P never reaches its
>>> final state at 1a72.
>>> (c) If H aborts its simulation of P then P never reaches its final
>>> state as 1a72.
>>> (d) Because P never halts in all possible cases H(P,P)==0 is always
>>> correct.
>>>
>>> The fact that there are no errors in (a)(b)(c) and (d) is a necessary
>>> consequence of (a)(b)(c) conclusively proves that (d) is correct.
>>>
>>> Halting problem undecidability and infinitely nested simulation (V2)
>>>
>>> https://www.researchgate.net/publication/356105750_Halting_problem_undecidability_and_infinitely_nested_simulation_V2
>>>
>>>
>>
>> Ye, for THAT H, you do have infinite recursion and THAT P is
>> non-halting, but THAT H never returns 0 for H(P,P) so it isn't a
>> correct halt decider.
>>
>
>

Re: Olcott wrong about infinite recursion [ simplest rebuttal of halting theorem ]

<hL6dnfx6kfTkHBD8nZ2dnUU7-ROdnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=23349&group=comp.theory#23349

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Thu, 11 Nov 2021 14:47:53 -0600
Date: Thu, 11 Nov 2021 14:47:51 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.3.0
Subject: Re: Olcott wrong about infinite recursion [ simplest rebuttal of
halting theorem ]
Content-Language: en-US
Newsgroups: comp.theory
References: <20211110215316.0000221e@reddwarf.jmc>
<ApydnX6D6fN31RH8nZ2dnUU7-UXNnZ2d@giganews.com>
<PFZiJ.19745$cW6.10169@fx08.iad> <20211111175240.00000a3b@reddwarf.jmc>
<upSdnfNv4q1S8RD8nZ2dnUU7-WXNnZ2d@giganews.com>
<rdejJ.20399$SW5.15061@fx45.iad>
<tIqdncrf0fM86xD8nZ2dnUU7-XednZ2d@giganews.com>
<NZejJ.21674$SW5.667@fx45.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <NZejJ.21674$SW5.667@fx45.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <hL6dnfx6kfTkHBD8nZ2dnUU7-ROdnZ2d@giganews.com>
Lines: 147
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-2LpHRMcuL4sEYefGQcZ5PwZVDpWNMUSgdp1KVsYaTAWmYyWUGfaKd7a7AkUDo85E/1vL0MzUC/Ma4+h!ofHPrct0EJ8lbstallGvaAY67BXBaIOTfyoKIC+fGARaMu+2QXUgZMMDMmzLrJvnc3SQnp8ai6AP!JQ==
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 7514
 by: olcott - Thu, 11 Nov 2021 20:47 UTC

On 11/11/2021 2:24 PM, Richard Damon wrote:
> On 11/11/21 3:01 PM, olcott wrote:
>> On 11/11/2021 1:32 PM, Richard Damon wrote:
>>>
>>> On 11/11/21 2:19 PM, olcott wrote:
>>>> On 11/11/2021 11:52 AM, Mr Flibble wrote:
>>>>> On Wed, 10 Nov 2021 19:42:23 -0500
>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>
>>>>>> On 11/10/21 5:34 PM, olcott wrote:
>>>>>>> On 11/10/2021 3:53 PM, Mr Flibble wrote:
>>>>>>>> Olcott is barking up the wrong tree re infinite recursion: there
>>>>>>>> is only a need to detect a single recursive call into the halt
>>>>>>>> decider and signal an exception.
>>>>>>>
>>>>>>> Yes, I figured that out. That eliminates the need for static local
>>>>>>> data thus allowing the halt decider to be a pure function.
>>>>>>
>>>>>> Except that this logic is only correct if the function is being
>>>>>> executed under unconditional execution.
>>>>>>
>>>>>> If the 'simulation' is being run under condition that can/will
>>>>>> terminate its execution, then the detection of this recursion is NOT
>>>>>> proof that the execution will be non-halting.
>>>>>>
>>>>>> All you have show is that IF the decider would never abort its
>>>>>> 'simulation' then the program would be non-halting.
>>>>>>
>>>>>> Since it turns out that the decider DOES abort its 'simulation', the
>>>>>> assumptions that the analysis was done under are not in fact true, so
>>>>>> the analysis is invalid.
>>>>>>
>>>>>>
>>>>>>>
>>>>>>> https://en.wikipedia.org/wiki/Pure_function
>>>>>>
>>>>>> But Software Engineering 'Pure Function' is NOT the Compution Theory
>>>>>> 'Computation', so you need to be aware of the difference.
>>>>>>
>>>>>>>
>>>>>>> That is why I needed my source-code analyzer to provide the exact
>>>>>>> number of parameters to every function.
>>>>>>>
>>>>>>> As long as the currently executing function (H) is called again
>>>>>>> with the same parameters then we know that this call will be
>>>>>>> infinitely recursive unless this infinite recursion is aborted at
>>>>>>> some point.
>>>>>>
>>>>>> Right, it would be infinite if NEVER aborted, but it IS aborted, so
>>>>>> it is not infinite, and since the machine uses a copy of the decider,
>>>>>> that same fact applies to it being run as an indepent computation,
>>>>>> since the decider inside it does abort its internal simulation, it
>>>>>> return the answer that allows the actual computation to be finint.
>>>>>>
>>>>>>>
>>>>>>> When H aborts this call to itself made by P then P never reaches
>>>>>>> its final state. If H never aborts this call made by P then P never
>>>>>>> reaches its final state. This conclusively proves that H can abort
>>>>>>> this call to itself and report that its input never halts.
>>>>>>
>>>>>>
>>>>>> But it doensn't matter that H's PARTIAL simulation of P reached the
>>>>>> halting point. When we run the actual computation, or give this input
>>>>>> to a REAL pure simulator, it will Halt.
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>> Here is the reference to my NumParams system:
>>>>>>> On 10/23/2021 8:27 PM, olcott wrote:
>>>>>>> [I finally completed my lexical analyzer generator (needed by my
>>>>>>> halt decider)]
>>>>>>> This system uses a DFA lexical analyzer to recognize
>>>>>>> the pattern of function declarations. This pattern is
>>>>>>> specified as 15 DFA states. The output is a C header
>>>>>>> file that looks up the function name specified in the
>>>>>>> COFF object file and returns its number of parameters.
>>>>>>>
>>>>>>
>>>>>> And where does this code get the source code of the program whose
>>>>>> COMPILED form has been given to H?
>>>>>>
>>>>>> Or, is H now being given the source code as the representation?
>>>>>>
>>>>>> Remember, if you do that, then that source code needs to contain the
>>>>>> FULL description of the program, which includes the code for H, and
>>>>>> everything it uses, which includes your NumParams and the compiler
>>>>>> you are going to put that code into.
>>>>>
>>>>> Nope, H needs to be a black box so its implementation is unknown to
>>>>> everyone but the creator of H.  If H is a black box it can safely
>>>>> detect recursion into it and signal an exception.
>>>>
>>>> That won't work because someone could write the same H as a whitebox.
>>>>
>>>> Here is my current enormously simplified proof:
>>>> Does the call from P() to H() specify infinite recursion?
>>>>
>>>> #define ptr uintptr_t
>>>>
>>>> void P(ptr x)
>>>> {
>>>>    H(x, x);
>>>> }
>>>>
>>>> int H(ptr x, ptr y)
>>>> {
>>>>    ((void(*)(ptr))x)(y);
>>>>    return 1;
>>>> }
>>>>
>>>> int main()
>>>> {
>>>>    H((ptr)P, (ptr)P);
>>>>    return 0;
>>>> }
>>>>
>>>> Yes it does.
>>>>
>>>> _P()
>>>> [00001a5e](01)  55              push ebp
>>>> [00001a5f](02)  8bec            mov ebp,esp
>>>> [00001a61](03)  8b4508          mov eax,[ebp+08]
>>>> [00001a64](01)  50              push eax        // push P
>>>> [00001a65](03)  8b4d08          mov ecx,[ebp+08]
>>>> [00001a68](01)  51              push ecx        // push P
>>>> [00001a69](05)  e810000000      call 00001a7e   // call H
>>>> [00001a6e](03)  83c408          add esp,+08
>>>> [00001a71](01)  5d              pop ebp
>>>> [00001a72](01)  c3              ret
>>>> Size in bytes:(0021) [00001a72]
>>
>>
>> YOU TOTALLY IGNORED ALL OF THESE NEXT WORDS
>> YOU TOTALLY IGNORED ALL OF THESE NEXT WORDS
>> YOU TOTALLY IGNORED ALL OF THESE NEXT WORDS
>> YOU TOTALLY IGNORED ALL OF THESE NEXT WORDS
>
> You can not use the 'proof' for the H that doesn't abort for the H that
> does, they are different Hs and create different Ps.
If in every H in the universe P never halts then P never halts.

--
Copyright 2021 Pete Olcott

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

Re: Olcott wrong about infinite recursion [ simplest rebuttal of halting theorem ]

<PNfjJ.21676$SW5.20549@fx45.iad>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=23350&group=comp.theory#23350

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!newsreader4.netcologne.de!news.netcologne.de!peer02.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx45.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.3.0
Subject: Re: Olcott wrong about infinite recursion [ simplest rebuttal of
halting theorem ]
Content-Language: en-US
Newsgroups: comp.theory
References: <20211110215316.0000221e@reddwarf.jmc>
<ApydnX6D6fN31RH8nZ2dnUU7-UXNnZ2d@giganews.com>
<PFZiJ.19745$cW6.10169@fx08.iad> <20211111175240.00000a3b@reddwarf.jmc>
<upSdnfNv4q1S8RD8nZ2dnUU7-WXNnZ2d@giganews.com>
<rdejJ.20399$SW5.15061@fx45.iad>
<tIqdncrf0fM86xD8nZ2dnUU7-XednZ2d@giganews.com>
<NZejJ.21674$SW5.667@fx45.iad>
<hL6dnfx6kfTkHBD8nZ2dnUU7-ROdnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <hL6dnfx6kfTkHBD8nZ2dnUU7-ROdnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 158
Message-ID: <PNfjJ.21676$SW5.20549@fx45.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Thu, 11 Nov 2021 16:19:44 -0500
X-Received-Bytes: 7896
 by: Richard Damon - Thu, 11 Nov 2021 21:19 UTC

On 11/11/21 3:47 PM, olcott wrote:
> On 11/11/2021 2:24 PM, Richard Damon wrote:
>> On 11/11/21 3:01 PM, olcott wrote:
>>> On 11/11/2021 1:32 PM, Richard Damon wrote:
>>>>
>>>> On 11/11/21 2:19 PM, olcott wrote:
>>>>> On 11/11/2021 11:52 AM, Mr Flibble wrote:
>>>>>> On Wed, 10 Nov 2021 19:42:23 -0500
>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>
>>>>>>> On 11/10/21 5:34 PM, olcott wrote:
>>>>>>>> On 11/10/2021 3:53 PM, Mr Flibble wrote:
>>>>>>>>> Olcott is barking up the wrong tree re infinite recursion: there
>>>>>>>>> is only a need to detect a single recursive call into the halt
>>>>>>>>> decider and signal an exception.
>>>>>>>>
>>>>>>>> Yes, I figured that out. That eliminates the need for static local
>>>>>>>> data thus allowing the halt decider to be a pure function.
>>>>>>>
>>>>>>> Except that this logic is only correct if the function is being
>>>>>>> executed under unconditional execution.
>>>>>>>
>>>>>>> If the 'simulation' is being run under condition that can/will
>>>>>>> terminate its execution, then the detection of this recursion is NOT
>>>>>>> proof that the execution will be non-halting.
>>>>>>>
>>>>>>> All you have show is that IF the decider would never abort its
>>>>>>> 'simulation' then the program would be non-halting.
>>>>>>>
>>>>>>> Since it turns out that the decider DOES abort its 'simulation', the
>>>>>>> assumptions that the analysis was done under are not in fact
>>>>>>> true, so
>>>>>>> the analysis is invalid.
>>>>>>>
>>>>>>>
>>>>>>>>
>>>>>>>> https://en.wikipedia.org/wiki/Pure_function
>>>>>>>
>>>>>>> But Software Engineering 'Pure Function' is NOT the Compution Theory
>>>>>>> 'Computation', so you need to be aware of the difference.
>>>>>>>
>>>>>>>>
>>>>>>>> That is why I needed my source-code analyzer to provide the exact
>>>>>>>> number of parameters to every function.
>>>>>>>>
>>>>>>>> As long as the currently executing function (H) is called again
>>>>>>>> with the same parameters then we know that this call will be
>>>>>>>> infinitely recursive unless this infinite recursion is aborted at
>>>>>>>> some point.
>>>>>>>
>>>>>>> Right, it would be infinite if NEVER aborted, but it IS aborted, so
>>>>>>> it is not infinite, and since the machine uses a copy of the
>>>>>>> decider,
>>>>>>> that same fact applies to it being run as an indepent computation,
>>>>>>> since the decider inside it does abort its internal simulation, it
>>>>>>> return the answer that allows the actual computation to be finint.
>>>>>>>
>>>>>>>>
>>>>>>>> When H aborts this call to itself made by P then P never reaches
>>>>>>>> its final state. If H never aborts this call made by P then P never
>>>>>>>> reaches its final state. This conclusively proves that H can abort
>>>>>>>> this call to itself and report that its input never halts.
>>>>>>>
>>>>>>>
>>>>>>> But it doensn't matter that H's PARTIAL simulation of P reached the
>>>>>>> halting point. When we run the actual computation, or give this
>>>>>>> input
>>>>>>> to a REAL pure simulator, it will Halt.
>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>> Here is the reference to my NumParams system:
>>>>>>>> On 10/23/2021 8:27 PM, olcott wrote:
>>>>>>>> [I finally completed my lexical analyzer generator (needed by my
>>>>>>>> halt decider)]
>>>>>>>> This system uses a DFA lexical analyzer to recognize
>>>>>>>> the pattern of function declarations. This pattern is
>>>>>>>> specified as 15 DFA states. The output is a C header
>>>>>>>> file that looks up the function name specified in the
>>>>>>>> COFF object file and returns its number of parameters.
>>>>>>>>
>>>>>>>
>>>>>>> And where does this code get the source code of the program whose
>>>>>>> COMPILED form has been given to H?
>>>>>>>
>>>>>>> Or, is H now being given the source code as the representation?
>>>>>>>
>>>>>>> Remember, if you do that, then that source code needs to contain the
>>>>>>> FULL description of the program, which includes the code for H, and
>>>>>>> everything it uses, which includes your NumParams and the compiler
>>>>>>> you are going to put that code into.
>>>>>>
>>>>>> Nope, H needs to be a black box so its implementation is unknown to
>>>>>> everyone but the creator of H.  If H is a black box it can safely
>>>>>> detect recursion into it and signal an exception.
>>>>>
>>>>> That won't work because someone could write the same H as a whitebox.
>>>>>
>>>>> Here is my current enormously simplified proof:
>>>>> Does the call from P() to H() specify infinite recursion?
>>>>>
>>>>> #define ptr uintptr_t
>>>>>
>>>>> void P(ptr x)
>>>>> {
>>>>>    H(x, x);
>>>>> }
>>>>>
>>>>> int H(ptr x, ptr y)
>>>>> {
>>>>>    ((void(*)(ptr))x)(y);
>>>>>    return 1;
>>>>> }
>>>>>
>>>>> int main()
>>>>> {
>>>>>    H((ptr)P, (ptr)P);
>>>>>    return 0;
>>>>> }
>>>>>
>>>>> Yes it does.
>>>>>
>>>>> _P()
>>>>> [00001a5e](01)  55              push ebp
>>>>> [00001a5f](02)  8bec            mov ebp,esp
>>>>> [00001a61](03)  8b4508          mov eax,[ebp+08]
>>>>> [00001a64](01)  50              push eax        // push P
>>>>> [00001a65](03)  8b4d08          mov ecx,[ebp+08]
>>>>> [00001a68](01)  51              push ecx        // push P
>>>>> [00001a69](05)  e810000000      call 00001a7e   // call H
>>>>> [00001a6e](03)  83c408          add esp,+08
>>>>> [00001a71](01)  5d              pop ebp
>>>>> [00001a72](01)  c3              ret
>>>>> Size in bytes:(0021) [00001a72]
>>>
>>>
>>> YOU TOTALLY IGNORED ALL OF THESE NEXT WORDS
>>> YOU TOTALLY IGNORED ALL OF THESE NEXT WORDS
>>> YOU TOTALLY IGNORED ALL OF THESE NEXT WORDS
>>> YOU TOTALLY IGNORED ALL OF THESE NEXT WORDS
>>
>> You can not use the 'proof' for the H that doesn't abort for the H
>> that does, they are different Hs and create different Ps.
> If in every H in the universe P never halts then P never halts.
>
>

Except most do.

For Any H that returns the value of 0 from H(P,P), then P(P) will halt.

Yes, the simulation inside H of P(P) will not reach its end state before
H aborts it simulation, but the actual running of P(P) or the simulaiton
with a REAL UTM will show that halting.

You are using the wrong definition of Halting, it doesn't matter about
the partial simulation in H, what matters is the actual execution of the
machine or its exact equivalent by the simulation with a real UTM.

Re: Olcott wrong about infinite recursion [ simplest rebuttal of halting theorem ]

<CpidnX-XCpQlEBD8nZ2dnUU7-QWdnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=23352&group=comp.theory#23352

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Thu, 11 Nov 2021 15:40:07 -0600
Date: Thu, 11 Nov 2021 15:40:06 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.3.0
Subject: Re: Olcott wrong about infinite recursion [ simplest rebuttal of
halting theorem ]
Content-Language: en-US
Newsgroups: comp.theory
References: <20211110215316.0000221e@reddwarf.jmc>
<ApydnX6D6fN31RH8nZ2dnUU7-UXNnZ2d@giganews.com>
<PFZiJ.19745$cW6.10169@fx08.iad> <20211111175240.00000a3b@reddwarf.jmc>
<upSdnfNv4q1S8RD8nZ2dnUU7-WXNnZ2d@giganews.com>
<rdejJ.20399$SW5.15061@fx45.iad>
<tIqdncrf0fM86xD8nZ2dnUU7-XednZ2d@giganews.com>
<NZejJ.21674$SW5.667@fx45.iad>
<hL6dnfx6kfTkHBD8nZ2dnUU7-ROdnZ2d@giganews.com>
<PNfjJ.21676$SW5.20549@fx45.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <PNfjJ.21676$SW5.20549@fx45.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <CpidnX-XCpQlEBD8nZ2dnUU7-QWdnZ2d@giganews.com>
Lines: 175
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-x3HU3CXApW/VxTIVclo6wByA36ok9q4borgAotO/Uuj21swRxQhacOhQe984uSvUxVvOzu+8hmA5BRH!QU+xWhDahe+RhLpw45yYDBIE8jBmnkCnN0a8OOzHIq6G/O85WESpHOl4ARPLjmUrys1+XXWJ9n9/!rQ==
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 8700
 by: olcott - Thu, 11 Nov 2021 21:40 UTC

On 11/11/2021 3:19 PM, Richard Damon wrote:
> On 11/11/21 3:47 PM, olcott wrote:
>> On 11/11/2021 2:24 PM, Richard Damon wrote:
>>> On 11/11/21 3:01 PM, olcott wrote:
>>>> On 11/11/2021 1:32 PM, Richard Damon wrote:
>>>>>
>>>>> On 11/11/21 2:19 PM, olcott wrote:
>>>>>> On 11/11/2021 11:52 AM, Mr Flibble wrote:
>>>>>>> On Wed, 10 Nov 2021 19:42:23 -0500
>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>
>>>>>>>> On 11/10/21 5:34 PM, olcott wrote:
>>>>>>>>> On 11/10/2021 3:53 PM, Mr Flibble wrote:
>>>>>>>>>> Olcott is barking up the wrong tree re infinite recursion: there
>>>>>>>>>> is only a need to detect a single recursive call into the halt
>>>>>>>>>> decider and signal an exception.
>>>>>>>>>
>>>>>>>>> Yes, I figured that out. That eliminates the need for static local
>>>>>>>>> data thus allowing the halt decider to be a pure function.
>>>>>>>>
>>>>>>>> Except that this logic is only correct if the function is being
>>>>>>>> executed under unconditional execution.
>>>>>>>>
>>>>>>>> If the 'simulation' is being run under condition that can/will
>>>>>>>> terminate its execution, then the detection of this recursion is
>>>>>>>> NOT
>>>>>>>> proof that the execution will be non-halting.
>>>>>>>>
>>>>>>>> All you have show is that IF the decider would never abort its
>>>>>>>> 'simulation' then the program would be non-halting.
>>>>>>>>
>>>>>>>> Since it turns out that the decider DOES abort its 'simulation',
>>>>>>>> the
>>>>>>>> assumptions that the analysis was done under are not in fact
>>>>>>>> true, so
>>>>>>>> the analysis is invalid.
>>>>>>>>
>>>>>>>>
>>>>>>>>>
>>>>>>>>> https://en.wikipedia.org/wiki/Pure_function
>>>>>>>>
>>>>>>>> But Software Engineering 'Pure Function' is NOT the Compution
>>>>>>>> Theory
>>>>>>>> 'Computation', so you need to be aware of the difference.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> That is why I needed my source-code analyzer to provide the exact
>>>>>>>>> number of parameters to every function.
>>>>>>>>>
>>>>>>>>> As long as the currently executing function (H) is called again
>>>>>>>>> with the same parameters then we know that this call will be
>>>>>>>>> infinitely recursive unless this infinite recursion is aborted at
>>>>>>>>> some point.
>>>>>>>>
>>>>>>>> Right, it would be infinite if NEVER aborted, but it IS aborted, so
>>>>>>>> it is not infinite, and since the machine uses a copy of the
>>>>>>>> decider,
>>>>>>>> that same fact applies to it being run as an indepent computation,
>>>>>>>> since the decider inside it does abort its internal simulation, it
>>>>>>>> return the answer that allows the actual computation to be finint.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> When H aborts this call to itself made by P then P never reaches
>>>>>>>>> its final state. If H never aborts this call made by P then P
>>>>>>>>> never
>>>>>>>>> reaches its final state. This conclusively proves that H can abort
>>>>>>>>> this call to itself and report that its input never halts.
>>>>>>>>
>>>>>>>>
>>>>>>>> But it doensn't matter that H's PARTIAL simulation of P reached the
>>>>>>>> halting point. When we run the actual computation, or give this
>>>>>>>> input
>>>>>>>> to a REAL pure simulator, it will Halt.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Here is the reference to my NumParams system:
>>>>>>>>> On 10/23/2021 8:27 PM, olcott wrote:
>>>>>>>>> [I finally completed my lexical analyzer generator (needed by my
>>>>>>>>> halt decider)]
>>>>>>>>> This system uses a DFA lexical analyzer to recognize
>>>>>>>>> the pattern of function declarations. This pattern is
>>>>>>>>> specified as 15 DFA states. The output is a C header
>>>>>>>>> file that looks up the function name specified in the
>>>>>>>>> COFF object file and returns its number of parameters.
>>>>>>>>>
>>>>>>>>
>>>>>>>> And where does this code get the source code of the program whose
>>>>>>>> COMPILED form has been given to H?
>>>>>>>>
>>>>>>>> Or, is H now being given the source code as the representation?
>>>>>>>>
>>>>>>>> Remember, if you do that, then that source code needs to contain
>>>>>>>> the
>>>>>>>> FULL description of the program, which includes the code for H, and
>>>>>>>> everything it uses, which includes your NumParams and the compiler
>>>>>>>> you are going to put that code into.
>>>>>>>
>>>>>>> Nope, H needs to be a black box so its implementation is unknown to
>>>>>>> everyone but the creator of H.  If H is a black box it can safely
>>>>>>> detect recursion into it and signal an exception.
>>>>>>
>>>>>> That won't work because someone could write the same H as a whitebox.
>>>>>>
>>>>>> Here is my current enormously simplified proof:
>>>>>> Does the call from P() to H() specify infinite recursion?
>>>>>>
>>>>>> #define ptr uintptr_t
>>>>>>
>>>>>> void P(ptr x)
>>>>>> {
>>>>>>    H(x, x);
>>>>>> }
>>>>>>
>>>>>> int H(ptr x, ptr y)
>>>>>> {
>>>>>>    ((void(*)(ptr))x)(y);
>>>>>>    return 1;
>>>>>> }
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>>    H((ptr)P, (ptr)P);
>>>>>>    return 0;
>>>>>> }
>>>>>>
>>>>>> Yes it does.
>>>>>>
>>>>>> _P()
>>>>>> [00001a5e](01)  55              push ebp
>>>>>> [00001a5f](02)  8bec            mov ebp,esp
>>>>>> [00001a61](03)  8b4508          mov eax,[ebp+08]
>>>>>> [00001a64](01)  50              push eax        // push P
>>>>>> [00001a65](03)  8b4d08          mov ecx,[ebp+08]
>>>>>> [00001a68](01)  51              push ecx        // push P
>>>>>> [00001a69](05)  e810000000      call 00001a7e   // call H
>>>>>> [00001a6e](03)  83c408          add esp,+08
>>>>>> [00001a71](01)  5d              pop ebp
>>>>>> [00001a72](01)  c3              ret
>>>>>> Size in bytes:(0021) [00001a72]
>>>>
>>>>
>>>> YOU TOTALLY IGNORED ALL OF THESE NEXT WORDS
>>>> YOU TOTALLY IGNORED ALL OF THESE NEXT WORDS
>>>> YOU TOTALLY IGNORED ALL OF THESE NEXT WORDS
>>>> YOU TOTALLY IGNORED ALL OF THESE NEXT WORDS
>>>
>>> You can not use the 'proof' for the H that doesn't abort for the H
>>> that does, they are different Hs and create different Ps.
>> If in every H in the universe P never halts then P never halts.
>>
>>
>
> Except most do.
>
> For Any H that returns the value of 0 from H(P,P), then P(P) will halt.
>


Click here to read the complete article
Re: Olcott wrong about infinite recursion [ simplest rebuttal of halting theorem ]

<lAgjJ.30976$3q9.23015@fx47.iad>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=23355&group=comp.theory#23355

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!paganini.bofh.team!news.dns-netz.com!news.freedyn.net!newsreader4.netcologne.de!news.netcologne.de!peer03.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx47.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.3.0
Subject: Re: Olcott wrong about infinite recursion [ simplest rebuttal of
halting theorem ]
Content-Language: en-US
Newsgroups: comp.theory
References: <20211110215316.0000221e@reddwarf.jmc>
<ApydnX6D6fN31RH8nZ2dnUU7-UXNnZ2d@giganews.com>
<PFZiJ.19745$cW6.10169@fx08.iad> <20211111175240.00000a3b@reddwarf.jmc>
<upSdnfNv4q1S8RD8nZ2dnUU7-WXNnZ2d@giganews.com>
<rdejJ.20399$SW5.15061@fx45.iad>
<tIqdncrf0fM86xD8nZ2dnUU7-XednZ2d@giganews.com>
<NZejJ.21674$SW5.667@fx45.iad>
<hL6dnfx6kfTkHBD8nZ2dnUU7-ROdnZ2d@giganews.com>
<PNfjJ.21676$SW5.20549@fx45.iad>
<CpidnX-XCpQlEBD8nZ2dnUU7-QWdnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <CpidnX-XCpQlEBD8nZ2dnUU7-QWdnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 192
Message-ID: <lAgjJ.30976$3q9.23015@fx47.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Thu, 11 Nov 2021 17:13:37 -0500
X-Received-Bytes: 9133
 by: Richard Damon - Thu, 11 Nov 2021 22:13 UTC

On 11/11/21 4:40 PM, olcott wrote:
> On 11/11/2021 3:19 PM, Richard Damon wrote:
>> On 11/11/21 3:47 PM, olcott wrote:
>>> On 11/11/2021 2:24 PM, Richard Damon wrote:
>>>> On 11/11/21 3:01 PM, olcott wrote:
>>>>> On 11/11/2021 1:32 PM, Richard Damon wrote:
>>>>>>
>>>>>> On 11/11/21 2:19 PM, olcott wrote:
>>>>>>> On 11/11/2021 11:52 AM, Mr Flibble wrote:
>>>>>>>> On Wed, 10 Nov 2021 19:42:23 -0500
>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>>
>>>>>>>>> On 11/10/21 5:34 PM, olcott wrote:
>>>>>>>>>> On 11/10/2021 3:53 PM, Mr Flibble wrote:
>>>>>>>>>>> Olcott is barking up the wrong tree re infinite recursion: there
>>>>>>>>>>> is only a need to detect a single recursive call into the halt
>>>>>>>>>>> decider and signal an exception.
>>>>>>>>>>
>>>>>>>>>> Yes, I figured that out. That eliminates the need for static
>>>>>>>>>> local
>>>>>>>>>> data thus allowing the halt decider to be a pure function.
>>>>>>>>>
>>>>>>>>> Except that this logic is only correct if the function is being
>>>>>>>>> executed under unconditional execution.
>>>>>>>>>
>>>>>>>>> If the 'simulation' is being run under condition that can/will
>>>>>>>>> terminate its execution, then the detection of this recursion
>>>>>>>>> is NOT
>>>>>>>>> proof that the execution will be non-halting.
>>>>>>>>>
>>>>>>>>> All you have show is that IF the decider would never abort its
>>>>>>>>> 'simulation' then the program would be non-halting.
>>>>>>>>>
>>>>>>>>> Since it turns out that the decider DOES abort its
>>>>>>>>> 'simulation', the
>>>>>>>>> assumptions that the analysis was done under are not in fact
>>>>>>>>> true, so
>>>>>>>>> the analysis is invalid.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> https://en.wikipedia.org/wiki/Pure_function
>>>>>>>>>
>>>>>>>>> But Software Engineering 'Pure Function' is NOT the Compution
>>>>>>>>> Theory
>>>>>>>>> 'Computation', so you need to be aware of the difference.
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> That is why I needed my source-code analyzer to provide the exact
>>>>>>>>>> number of parameters to every function.
>>>>>>>>>>
>>>>>>>>>> As long as the currently executing function (H) is called again
>>>>>>>>>> with the same parameters then we know that this call will be
>>>>>>>>>> infinitely recursive unless this infinite recursion is aborted at
>>>>>>>>>> some point.
>>>>>>>>>
>>>>>>>>> Right, it would be infinite if NEVER aborted, but it IS
>>>>>>>>> aborted, so
>>>>>>>>> it is not infinite, and since the machine uses a copy of the
>>>>>>>>> decider,
>>>>>>>>> that same fact applies to it being run as an indepent computation,
>>>>>>>>> since the decider inside it does abort its internal simulation, it
>>>>>>>>> return the answer that allows the actual computation to be finint.
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> When H aborts this call to itself made by P then P never reaches
>>>>>>>>>> its final state. If H never aborts this call made by P then P
>>>>>>>>>> never
>>>>>>>>>> reaches its final state. This conclusively proves that H can
>>>>>>>>>> abort
>>>>>>>>>> this call to itself and report that its input never halts.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> But it doensn't matter that H's PARTIAL simulation of P reached
>>>>>>>>> the
>>>>>>>>> halting point. When we run the actual computation, or give this
>>>>>>>>> input
>>>>>>>>> to a REAL pure simulator, it will Halt.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Here is the reference to my NumParams system:
>>>>>>>>>> On 10/23/2021 8:27 PM, olcott wrote:
>>>>>>>>>> [I finally completed my lexical analyzer generator (needed by my
>>>>>>>>>> halt decider)]
>>>>>>>>>> This system uses a DFA lexical analyzer to recognize
>>>>>>>>>> the pattern of function declarations. This pattern is
>>>>>>>>>> specified as 15 DFA states. The output is a C header
>>>>>>>>>> file that looks up the function name specified in the
>>>>>>>>>> COFF object file and returns its number of parameters.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> And where does this code get the source code of the program whose
>>>>>>>>> COMPILED form has been given to H?
>>>>>>>>>
>>>>>>>>> Or, is H now being given the source code as the representation?
>>>>>>>>>
>>>>>>>>> Remember, if you do that, then that source code needs to
>>>>>>>>> contain the
>>>>>>>>> FULL description of the program, which includes the code for H,
>>>>>>>>> and
>>>>>>>>> everything it uses, which includes your NumParams and the compiler
>>>>>>>>> you are going to put that code into.
>>>>>>>>
>>>>>>>> Nope, H needs to be a black box so its implementation is unknown to
>>>>>>>> everyone but the creator of H.  If H is a black box it can safely
>>>>>>>> detect recursion into it and signal an exception.
>>>>>>>
>>>>>>> That won't work because someone could write the same H as a
>>>>>>> whitebox.
>>>>>>>
>>>>>>> Here is my current enormously simplified proof:
>>>>>>> Does the call from P() to H() specify infinite recursion?
>>>>>>>
>>>>>>> #define ptr uintptr_t
>>>>>>>
>>>>>>> void P(ptr x)
>>>>>>> {
>>>>>>>    H(x, x);
>>>>>>> }
>>>>>>>
>>>>>>> int H(ptr x, ptr y)
>>>>>>> {
>>>>>>>    ((void(*)(ptr))x)(y);
>>>>>>>    return 1;
>>>>>>> }
>>>>>>>
>>>>>>> int main()
>>>>>>> {
>>>>>>>    H((ptr)P, (ptr)P);
>>>>>>>    return 0;
>>>>>>> }
>>>>>>>
>>>>>>> Yes it does.
>>>>>>>
>>>>>>> _P()
>>>>>>> [00001a5e](01)  55              push ebp
>>>>>>> [00001a5f](02)  8bec            mov ebp,esp
>>>>>>> [00001a61](03)  8b4508          mov eax,[ebp+08]
>>>>>>> [00001a64](01)  50              push eax        // push P
>>>>>>> [00001a65](03)  8b4d08          mov ecx,[ebp+08]
>>>>>>> [00001a68](01)  51              push ecx        // push P
>>>>>>> [00001a69](05)  e810000000      call 00001a7e   // call H
>>>>>>> [00001a6e](03)  83c408          add esp,+08
>>>>>>> [00001a71](01)  5d              pop ebp
>>>>>>> [00001a72](01)  c3              ret
>>>>>>> Size in bytes:(0021) [00001a72]
>>>>>
>>>>>
>>>>> YOU TOTALLY IGNORED ALL OF THESE NEXT WORDS
>>>>> YOU TOTALLY IGNORED ALL OF THESE NEXT WORDS
>>>>> YOU TOTALLY IGNORED ALL OF THESE NEXT WORDS
>>>>> YOU TOTALLY IGNORED ALL OF THESE NEXT WORDS
>>>>
>>>> You can not use the 'proof' for the H that doesn't abort for the H
>>>> that does, they are different Hs and create different Ps.
>>> If in every H in the universe P never halts then P never halts.
>>>
>>>
>>
>> Except most do.
>>
>> For Any H that returns the value of 0 from H(P,P), then P(P) will halt.
>>
>
> For every H in the universe no P ever reaches its machine code address
> of 1a72, thus no P ever halts.


Click here to read the complete article
Re: Olcott wrong about infinite recursion [ simplest rebuttal of halting theorem ] [ Ben's changes ]

<jtadnVpTvr8HABD8nZ2dnUU7-d_NnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=23360&group=comp.theory#23360

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Thu, 11 Nov 2021 16:47:54 -0600
Date: Thu, 11 Nov 2021 16:47:52 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.3.0
Subject: Re: Olcott wrong about infinite recursion [ simplest rebuttal of
halting theorem ] [ Ben's changes ]
Content-Language: en-US
Newsgroups: comp.theory
References: <20211110215316.0000221e@reddwarf.jmc>
<ApydnX6D6fN31RH8nZ2dnUU7-UXNnZ2d@giganews.com>
<PFZiJ.19745$cW6.10169@fx08.iad> <20211111175240.00000a3b@reddwarf.jmc>
<upSdnfNv4q1S8RD8nZ2dnUU7-WXNnZ2d@giganews.com>
<rdejJ.20399$SW5.15061@fx45.iad>
<tIqdncrf0fM86xD8nZ2dnUU7-XednZ2d@giganews.com>
<NZejJ.21674$SW5.667@fx45.iad>
<hL6dnfx6kfTkHBD8nZ2dnUU7-ROdnZ2d@giganews.com>
<PNfjJ.21676$SW5.20549@fx45.iad>
<CpidnX-XCpQlEBD8nZ2dnUU7-QWdnZ2d@giganews.com>
<lAgjJ.30976$3q9.23015@fx47.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <lAgjJ.30976$3q9.23015@fx47.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <jtadnVpTvr8HABD8nZ2dnUU7-d_NnZ2d@giganews.com>
Lines: 211
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-VxPkgE51RK0e6tstC7C2/Ykd5A5tAFCLPZgqRXANc7mON3lpziuRnW+0/oiqqkpP7yYh0uWvXSy8s+h!XiU05ZEK+ir+aXqpyZG6nvgsMw8BdpBTDz+XfPgSkR37WvMK84pyNY7kMSPJKM1zsTRsPbnP5wF0!DA==
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 9574
 by: olcott - Thu, 11 Nov 2021 22:47 UTC

On 11/11/2021 4:13 PM, Richard Damon wrote:
> On 11/11/21 4:40 PM, olcott wrote:
>> On 11/11/2021 3:19 PM, Richard Damon wrote:
>>> On 11/11/21 3:47 PM, olcott wrote:
>>>> On 11/11/2021 2:24 PM, Richard Damon wrote:
>>>>> On 11/11/21 3:01 PM, olcott wrote:
>>>>>> On 11/11/2021 1:32 PM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 11/11/21 2:19 PM, olcott wrote:
>>>>>>>> On 11/11/2021 11:52 AM, Mr Flibble wrote:
>>>>>>>>> On Wed, 10 Nov 2021 19:42:23 -0500
>>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>>>
>>>>>>>>>> On 11/10/21 5:34 PM, olcott wrote:
>>>>>>>>>>> On 11/10/2021 3:53 PM, Mr Flibble wrote:
>>>>>>>>>>>> Olcott is barking up the wrong tree re infinite recursion:
>>>>>>>>>>>> there
>>>>>>>>>>>> is only a need to detect a single recursive call into the halt
>>>>>>>>>>>> decider and signal an exception.
>>>>>>>>>>>
>>>>>>>>>>> Yes, I figured that out. That eliminates the need for static
>>>>>>>>>>> local
>>>>>>>>>>> data thus allowing the halt decider to be a pure function.
>>>>>>>>>>
>>>>>>>>>> Except that this logic is only correct if the function is being
>>>>>>>>>> executed under unconditional execution.
>>>>>>>>>>
>>>>>>>>>> If the 'simulation' is being run under condition that can/will
>>>>>>>>>> terminate its execution, then the detection of this recursion
>>>>>>>>>> is NOT
>>>>>>>>>> proof that the execution will be non-halting.
>>>>>>>>>>
>>>>>>>>>> All you have show is that IF the decider would never abort its
>>>>>>>>>> 'simulation' then the program would be non-halting.
>>>>>>>>>>
>>>>>>>>>> Since it turns out that the decider DOES abort its
>>>>>>>>>> 'simulation', the
>>>>>>>>>> assumptions that the analysis was done under are not in fact
>>>>>>>>>> true, so
>>>>>>>>>> the analysis is invalid.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> https://en.wikipedia.org/wiki/Pure_function
>>>>>>>>>>
>>>>>>>>>> But Software Engineering 'Pure Function' is NOT the Compution
>>>>>>>>>> Theory
>>>>>>>>>> 'Computation', so you need to be aware of the difference.
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> That is why I needed my source-code analyzer to provide the
>>>>>>>>>>> exact
>>>>>>>>>>> number of parameters to every function.
>>>>>>>>>>>
>>>>>>>>>>> As long as the currently executing function (H) is called again
>>>>>>>>>>> with the same parameters then we know that this call will be
>>>>>>>>>>> infinitely recursive unless this infinite recursion is
>>>>>>>>>>> aborted at
>>>>>>>>>>> some point.
>>>>>>>>>>
>>>>>>>>>> Right, it would be infinite if NEVER aborted, but it IS
>>>>>>>>>> aborted, so
>>>>>>>>>> it is not infinite, and since the machine uses a copy of the
>>>>>>>>>> decider,
>>>>>>>>>> that same fact applies to it being run as an indepent
>>>>>>>>>> computation,
>>>>>>>>>> since the decider inside it does abort its internal
>>>>>>>>>> simulation, it
>>>>>>>>>> return the answer that allows the actual computation to be
>>>>>>>>>> finint.
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> When H aborts this call to itself made by P then P never reaches
>>>>>>>>>>> its final state. If H never aborts this call made by P then P
>>>>>>>>>>> never
>>>>>>>>>>> reaches its final state. This conclusively proves that H can
>>>>>>>>>>> abort
>>>>>>>>>>> this call to itself and report that its input never halts.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> But it doensn't matter that H's PARTIAL simulation of P
>>>>>>>>>> reached the
>>>>>>>>>> halting point. When we run the actual computation, or give
>>>>>>>>>> this input
>>>>>>>>>> to a REAL pure simulator, it will Halt.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Here is the reference to my NumParams system:
>>>>>>>>>>> On 10/23/2021 8:27 PM, olcott wrote:
>>>>>>>>>>> [I finally completed my lexical analyzer generator (needed by my
>>>>>>>>>>> halt decider)]
>>>>>>>>>>> This system uses a DFA lexical analyzer to recognize
>>>>>>>>>>> the pattern of function declarations. This pattern is
>>>>>>>>>>> specified as 15 DFA states. The output is a C header
>>>>>>>>>>> file that looks up the function name specified in the
>>>>>>>>>>> COFF object file and returns its number of parameters.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> And where does this code get the source code of the program whose
>>>>>>>>>> COMPILED form has been given to H?
>>>>>>>>>>
>>>>>>>>>> Or, is H now being given the source code as the representation?
>>>>>>>>>>
>>>>>>>>>> Remember, if you do that, then that source code needs to
>>>>>>>>>> contain the
>>>>>>>>>> FULL description of the program, which includes the code for
>>>>>>>>>> H, and
>>>>>>>>>> everything it uses, which includes your NumParams and the
>>>>>>>>>> compiler
>>>>>>>>>> you are going to put that code into.
>>>>>>>>>
>>>>>>>>> Nope, H needs to be a black box so its implementation is
>>>>>>>>> unknown to
>>>>>>>>> everyone but the creator of H.  If H is a black box it can safely
>>>>>>>>> detect recursion into it and signal an exception.
>>>>>>>>
>>>>>>>> That won't work because someone could write the same H as a
>>>>>>>> whitebox.
>>>>>>>>
>>>>>>>> Here is my current enormously simplified proof:
>>>>>>>> Does the call from P() to H() specify infinite recursion?
>>>>>>>>
>>>>>>>> #define ptr uintptr_t
>>>>>>>>
>>>>>>>> void P(ptr x)
>>>>>>>> {
>>>>>>>>    H(x, x);
>>>>>>>> }
>>>>>>>>
>>>>>>>> int H(ptr x, ptr y)
>>>>>>>> {
>>>>>>>>    ((void(*)(ptr))x)(y);
>>>>>>>>    return 1;
>>>>>>>> }
>>>>>>>>
>>>>>>>> int main()
>>>>>>>> {
>>>>>>>>    H((ptr)P, (ptr)P);
>>>>>>>>    return 0;
>>>>>>>> }
>>>>>>>>
>>>>>>>> Yes it does.
>>>>>>>>
>>>>>>>> _P()
>>>>>>>> [00001a5e](01)  55              push ebp
>>>>>>>> [00001a5f](02)  8bec            mov ebp,esp
>>>>>>>> [00001a61](03)  8b4508          mov eax,[ebp+08]
>>>>>>>> [00001a64](01)  50              push eax        // push P
>>>>>>>> [00001a65](03)  8b4d08          mov ecx,[ebp+08]
>>>>>>>> [00001a68](01)  51              push ecx        // push P
>>>>>>>> [00001a69](05)  e810000000      call 00001a7e   // call H
>>>>>>>> [00001a6e](03)  83c408          add esp,+08
>>>>>>>> [00001a71](01)  5d              pop ebp
>>>>>>>> [00001a72](01)  c3              ret
>>>>>>>> Size in bytes:(0021) [00001a72]
>>>>>>
>>>>>>
>>>>>> YOU TOTALLY IGNORED ALL OF THESE NEXT WORDS
>>>>>> YOU TOTALLY IGNORED ALL OF THESE NEXT WORDS
>>>>>> YOU TOTALLY IGNORED ALL OF THESE NEXT WORDS
>>>>>> YOU TOTALLY IGNORED ALL OF THESE NEXT WORDS
>>>>>
>>>>> You can not use the 'proof' for the H that doesn't abort for the H
>>>>> that does, they are different Hs and create different Ps.
>>>> If in every H in the universe P never halts then P never halts.
>>>>
>>>>
>>>
>>> Except most do.
>>>
>>> For Any H that returns the value of 0 from H(P,P), then P(P) will halt.
>>>
>>
>> For every H in the universe no P ever reaches its machine code address
>> of 1a72, thus no P ever halts.
>
> Except that you are too dumb to realize that they do. They may not reach
> that point in the PARTIAL simulation that H does, but they do in the
> REAL simulation by a proper PURE simulation, or by the direct running of
> the machine.
Ben did an absolutely brilliant job of simplifying the syntax of my
code. Perhaps you can comprehend that the printf is never reached?


Click here to read the complete article
Re: Olcott wrong about infinite recursion [ simplest rebuttal of halting theorem ] [ Ben's changes ]

<ahhjJ.16203$b%.15269@fx24.iad>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=23362&group=comp.theory#23362

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!feeder5.feed.usenet.farm!feeder1.feed.usenet.farm!feed.usenet.farm!peer03.ams4!peer.am4.highwinds-media.com!peer03.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx24.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.3.0
Subject: Re: Olcott wrong about infinite recursion [ simplest rebuttal of
halting theorem ] [ Ben's changes ]
Content-Language: en-US
Newsgroups: comp.theory
References: <20211110215316.0000221e@reddwarf.jmc>
<ApydnX6D6fN31RH8nZ2dnUU7-UXNnZ2d@giganews.com>
<PFZiJ.19745$cW6.10169@fx08.iad> <20211111175240.00000a3b@reddwarf.jmc>
<upSdnfNv4q1S8RD8nZ2dnUU7-WXNnZ2d@giganews.com>
<rdejJ.20399$SW5.15061@fx45.iad>
<tIqdncrf0fM86xD8nZ2dnUU7-XednZ2d@giganews.com>
<NZejJ.21674$SW5.667@fx45.iad>
<hL6dnfx6kfTkHBD8nZ2dnUU7-ROdnZ2d@giganews.com>
<PNfjJ.21676$SW5.20549@fx45.iad>
<CpidnX-XCpQlEBD8nZ2dnUU7-QWdnZ2d@giganews.com>
<lAgjJ.30976$3q9.23015@fx47.iad>
<jtadnVpTvr8HABD8nZ2dnUU7-d_NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <jtadnVpTvr8HABD8nZ2dnUU7-d_NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 225
Message-ID: <ahhjJ.16203$b%.15269@fx24.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Thu, 11 Nov 2021 18:01:26 -0500
X-Received-Bytes: 10102
 by: Richard Damon - Thu, 11 Nov 2021 23:01 UTC

On 11/11/21 5:47 PM, olcott wrote:
> On 11/11/2021 4:13 PM, Richard Damon wrote:
>> On 11/11/21 4:40 PM, olcott wrote:
>>> On 11/11/2021 3:19 PM, Richard Damon wrote:
>>>> On 11/11/21 3:47 PM, olcott wrote:
>>>>> On 11/11/2021 2:24 PM, Richard Damon wrote:
>>>>>> On 11/11/21 3:01 PM, olcott wrote:
>>>>>>> On 11/11/2021 1:32 PM, Richard Damon wrote:
>>>>>>>>
>>>>>>>> On 11/11/21 2:19 PM, olcott wrote:
>>>>>>>>> On 11/11/2021 11:52 AM, Mr Flibble wrote:
>>>>>>>>>> On Wed, 10 Nov 2021 19:42:23 -0500
>>>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>>>>
>>>>>>>>>>> On 11/10/21 5:34 PM, olcott wrote:
>>>>>>>>>>>> On 11/10/2021 3:53 PM, Mr Flibble wrote:
>>>>>>>>>>>>> Olcott is barking up the wrong tree re infinite recursion:
>>>>>>>>>>>>> there
>>>>>>>>>>>>> is only a need to detect a single recursive call into the halt
>>>>>>>>>>>>> decider and signal an exception.
>>>>>>>>>>>>
>>>>>>>>>>>> Yes, I figured that out. That eliminates the need for static
>>>>>>>>>>>> local
>>>>>>>>>>>> data thus allowing the halt decider to be a pure function.
>>>>>>>>>>>
>>>>>>>>>>> Except that this logic is only correct if the function is being
>>>>>>>>>>> executed under unconditional execution.
>>>>>>>>>>>
>>>>>>>>>>> If the 'simulation' is being run under condition that can/will
>>>>>>>>>>> terminate its execution, then the detection of this recursion
>>>>>>>>>>> is NOT
>>>>>>>>>>> proof that the execution will be non-halting.
>>>>>>>>>>>
>>>>>>>>>>> All you have show is that IF the decider would never abort its
>>>>>>>>>>> 'simulation' then the program would be non-halting.
>>>>>>>>>>>
>>>>>>>>>>> Since it turns out that the decider DOES abort its
>>>>>>>>>>> 'simulation', the
>>>>>>>>>>> assumptions that the analysis was done under are not in fact
>>>>>>>>>>> true, so
>>>>>>>>>>> the analysis is invalid.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> https://en.wikipedia.org/wiki/Pure_function
>>>>>>>>>>>
>>>>>>>>>>> But Software Engineering 'Pure Function' is NOT the Compution
>>>>>>>>>>> Theory
>>>>>>>>>>> 'Computation', so you need to be aware of the difference.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> That is why I needed my source-code analyzer to provide the
>>>>>>>>>>>> exact
>>>>>>>>>>>> number of parameters to every function.
>>>>>>>>>>>>
>>>>>>>>>>>> As long as the currently executing function (H) is called again
>>>>>>>>>>>> with the same parameters then we know that this call will be
>>>>>>>>>>>> infinitely recursive unless this infinite recursion is
>>>>>>>>>>>> aborted at
>>>>>>>>>>>> some point.
>>>>>>>>>>>
>>>>>>>>>>> Right, it would be infinite if NEVER aborted, but it IS
>>>>>>>>>>> aborted, so
>>>>>>>>>>> it is not infinite, and since the machine uses a copy of the
>>>>>>>>>>> decider,
>>>>>>>>>>> that same fact applies to it being run as an indepent
>>>>>>>>>>> computation,
>>>>>>>>>>> since the decider inside it does abort its internal
>>>>>>>>>>> simulation, it
>>>>>>>>>>> return the answer that allows the actual computation to be
>>>>>>>>>>> finint.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> When H aborts this call to itself made by P then P never
>>>>>>>>>>>> reaches
>>>>>>>>>>>> its final state. If H never aborts this call made by P then
>>>>>>>>>>>> P never
>>>>>>>>>>>> reaches its final state. This conclusively proves that H can
>>>>>>>>>>>> abort
>>>>>>>>>>>> this call to itself and report that its input never halts.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> But it doensn't matter that H's PARTIAL simulation of P
>>>>>>>>>>> reached the
>>>>>>>>>>> halting point. When we run the actual computation, or give
>>>>>>>>>>> this input
>>>>>>>>>>> to a REAL pure simulator, it will Halt.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Here is the reference to my NumParams system:
>>>>>>>>>>>> On 10/23/2021 8:27 PM, olcott wrote:
>>>>>>>>>>>> [I finally completed my lexical analyzer generator (needed
>>>>>>>>>>>> by my
>>>>>>>>>>>> halt decider)]
>>>>>>>>>>>> This system uses a DFA lexical analyzer to recognize
>>>>>>>>>>>> the pattern of function declarations. This pattern is
>>>>>>>>>>>> specified as 15 DFA states. The output is a C header
>>>>>>>>>>>> file that looks up the function name specified in the
>>>>>>>>>>>> COFF object file and returns its number of parameters.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> And where does this code get the source code of the program
>>>>>>>>>>> whose
>>>>>>>>>>> COMPILED form has been given to H?
>>>>>>>>>>>
>>>>>>>>>>> Or, is H now being given the source code as the representation?
>>>>>>>>>>>
>>>>>>>>>>> Remember, if you do that, then that source code needs to
>>>>>>>>>>> contain the
>>>>>>>>>>> FULL description of the program, which includes the code for
>>>>>>>>>>> H, and
>>>>>>>>>>> everything it uses, which includes your NumParams and the
>>>>>>>>>>> compiler
>>>>>>>>>>> you are going to put that code into.
>>>>>>>>>>
>>>>>>>>>> Nope, H needs to be a black box so its implementation is
>>>>>>>>>> unknown to
>>>>>>>>>> everyone but the creator of H.  If H is a black box it can safely
>>>>>>>>>> detect recursion into it and signal an exception.
>>>>>>>>>
>>>>>>>>> That won't work because someone could write the same H as a
>>>>>>>>> whitebox.
>>>>>>>>>
>>>>>>>>> Here is my current enormously simplified proof:
>>>>>>>>> Does the call from P() to H() specify infinite recursion?
>>>>>>>>>
>>>>>>>>> #define ptr uintptr_t
>>>>>>>>>
>>>>>>>>> void P(ptr x)
>>>>>>>>> {
>>>>>>>>>    H(x, x);
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> int H(ptr x, ptr y)
>>>>>>>>> {
>>>>>>>>>    ((void(*)(ptr))x)(y);
>>>>>>>>>    return 1;
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> int main()
>>>>>>>>> {
>>>>>>>>>    H((ptr)P, (ptr)P);
>>>>>>>>>    return 0;
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> Yes it does.
>>>>>>>>>
>>>>>>>>> _P()
>>>>>>>>> [00001a5e](01)  55              push ebp
>>>>>>>>> [00001a5f](02)  8bec            mov ebp,esp
>>>>>>>>> [00001a61](03)  8b4508          mov eax,[ebp+08]
>>>>>>>>> [00001a64](01)  50              push eax        // push P
>>>>>>>>> [00001a65](03)  8b4d08          mov ecx,[ebp+08]
>>>>>>>>> [00001a68](01)  51              push ecx        // push P
>>>>>>>>> [00001a69](05)  e810000000      call 00001a7e   // call H
>>>>>>>>> [00001a6e](03)  83c408          add esp,+08
>>>>>>>>> [00001a71](01)  5d              pop ebp
>>>>>>>>> [00001a72](01)  c3              ret
>>>>>>>>> Size in bytes:(0021) [00001a72]
>>>>>>>
>>>>>>>
>>>>>>> YOU TOTALLY IGNORED ALL OF THESE NEXT WORDS
>>>>>>> YOU TOTALLY IGNORED ALL OF THESE NEXT WORDS
>>>>>>> YOU TOTALLY IGNORED ALL OF THESE NEXT WORDS
>>>>>>> YOU TOTALLY IGNORED ALL OF THESE NEXT WORDS
>>>>>>
>>>>>> You can not use the 'proof' for the H that doesn't abort for the H
>>>>>> that does, they are different Hs and create different Ps.
>>>>> If in every H in the universe P never halts then P never halts.
>>>>>
>>>>>
>>>>
>>>> Except most do.
>>>>
>>>> For Any H that returns the value of 0 from H(P,P), then P(P) will halt.
>>>>
>>>
>>> For every H in the universe no P ever reaches its machine code
>>> address of 1a72, thus no P ever halts.
>>
>> Except that you are too dumb to realize that they do. They may not
>> reach that point in the PARTIAL simulation that H does, but they do in
>> the REAL simulation by a proper PURE simulation, or by the direct
>> running of the machine.
> Ben did an absolutely brilliant job of simplifying the syntax of my
> code. Perhaps you can comprehend that the printf is never reached?


Click here to read the complete article
Re: Olcott wrong about infinite recursion [ simplest rebuttal of halting theorem ] [ Ben's changes ]

<-JOdnabQjsW9PhD8nZ2dnUU7-W3NnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=23364&group=comp.theory#23364

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Thu, 11 Nov 2021 17:11:28 -0600
Date: Thu, 11 Nov 2021 17:11:26 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.3.0
Subject: Re: Olcott wrong about infinite recursion [ simplest rebuttal of
halting theorem ] [ Ben's changes ]
Content-Language: en-US
Newsgroups: comp.theory
References: <20211110215316.0000221e@reddwarf.jmc>
<ApydnX6D6fN31RH8nZ2dnUU7-UXNnZ2d@giganews.com>
<PFZiJ.19745$cW6.10169@fx08.iad> <20211111175240.00000a3b@reddwarf.jmc>
<upSdnfNv4q1S8RD8nZ2dnUU7-WXNnZ2d@giganews.com>
<rdejJ.20399$SW5.15061@fx45.iad>
<tIqdncrf0fM86xD8nZ2dnUU7-XednZ2d@giganews.com>
<NZejJ.21674$SW5.667@fx45.iad>
<hL6dnfx6kfTkHBD8nZ2dnUU7-ROdnZ2d@giganews.com>
<PNfjJ.21676$SW5.20549@fx45.iad>
<CpidnX-XCpQlEBD8nZ2dnUU7-QWdnZ2d@giganews.com>
<lAgjJ.30976$3q9.23015@fx47.iad>
<jtadnVpTvr8HABD8nZ2dnUU7-d_NnZ2d@giganews.com>
<ahhjJ.16203$b%.15269@fx24.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <ahhjJ.16203$b%.15269@fx24.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <-JOdnabQjsW9PhD8nZ2dnUU7-W3NnZ2d@giganews.com>
Lines: 247
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-OIOz1CiBYRFMAAtKhaGBSsYUdKIDb38AWmn2Xm/rb2kFr1OQJx3O/hwvGuAoV3WXE5lhECEk7iNT45A!NL1nbWjZFMDPZxJ3zMu+rZILw9z9kMovCpAXcofLwNroHwJIV+YUKhvg9+Myol121uCBOycQK3Y2!oA==
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 11165
 by: olcott - Thu, 11 Nov 2021 23:11 UTC

On 11/11/2021 5:01 PM, Richard Damon wrote:
> On 11/11/21 5:47 PM, olcott wrote:
>> On 11/11/2021 4:13 PM, Richard Damon wrote:
>>> On 11/11/21 4:40 PM, olcott wrote:
>>>> On 11/11/2021 3:19 PM, Richard Damon wrote:
>>>>> On 11/11/21 3:47 PM, olcott wrote:
>>>>>> On 11/11/2021 2:24 PM, Richard Damon wrote:
>>>>>>> On 11/11/21 3:01 PM, olcott wrote:
>>>>>>>> On 11/11/2021 1:32 PM, Richard Damon wrote:
>>>>>>>>>
>>>>>>>>> On 11/11/21 2:19 PM, olcott wrote:
>>>>>>>>>> On 11/11/2021 11:52 AM, Mr Flibble wrote:
>>>>>>>>>>> On Wed, 10 Nov 2021 19:42:23 -0500
>>>>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>>>>>
>>>>>>>>>>>> On 11/10/21 5:34 PM, olcott wrote:
>>>>>>>>>>>>> On 11/10/2021 3:53 PM, Mr Flibble wrote:
>>>>>>>>>>>>>> Olcott is barking up the wrong tree re infinite recursion:
>>>>>>>>>>>>>> there
>>>>>>>>>>>>>> is only a need to detect a single recursive call into the
>>>>>>>>>>>>>> halt
>>>>>>>>>>>>>> decider and signal an exception.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Yes, I figured that out. That eliminates the need for
>>>>>>>>>>>>> static local
>>>>>>>>>>>>> data thus allowing the halt decider to be a pure function.
>>>>>>>>>>>>
>>>>>>>>>>>> Except that this logic is only correct if the function is being
>>>>>>>>>>>> executed under unconditional execution.
>>>>>>>>>>>>
>>>>>>>>>>>> If the 'simulation' is being run under condition that can/will
>>>>>>>>>>>> terminate its execution, then the detection of this
>>>>>>>>>>>> recursion is NOT
>>>>>>>>>>>> proof that the execution will be non-halting.
>>>>>>>>>>>>
>>>>>>>>>>>> All you have show is that IF the decider would never abort its
>>>>>>>>>>>> 'simulation' then the program would be non-halting.
>>>>>>>>>>>>
>>>>>>>>>>>> Since it turns out that the decider DOES abort its
>>>>>>>>>>>> 'simulation', the
>>>>>>>>>>>> assumptions that the analysis was done under are not in fact
>>>>>>>>>>>> true, so
>>>>>>>>>>>> the analysis is invalid.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Pure_function
>>>>>>>>>>>>
>>>>>>>>>>>> But Software Engineering 'Pure Function' is NOT the
>>>>>>>>>>>> Compution Theory
>>>>>>>>>>>> 'Computation', so you need to be aware of the difference.
>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> That is why I needed my source-code analyzer to provide the
>>>>>>>>>>>>> exact
>>>>>>>>>>>>> number of parameters to every function.
>>>>>>>>>>>>>
>>>>>>>>>>>>> As long as the currently executing function (H) is called
>>>>>>>>>>>>> again
>>>>>>>>>>>>> with the same parameters then we know that this call will be
>>>>>>>>>>>>> infinitely recursive unless this infinite recursion is
>>>>>>>>>>>>> aborted at
>>>>>>>>>>>>> some point.
>>>>>>>>>>>>
>>>>>>>>>>>> Right, it would be infinite if NEVER aborted, but it IS
>>>>>>>>>>>> aborted, so
>>>>>>>>>>>> it is not infinite, and since the machine uses a copy of the
>>>>>>>>>>>> decider,
>>>>>>>>>>>> that same fact applies to it being run as an indepent
>>>>>>>>>>>> computation,
>>>>>>>>>>>> since the decider inside it does abort its internal
>>>>>>>>>>>> simulation, it
>>>>>>>>>>>> return the answer that allows the actual computation to be
>>>>>>>>>>>> finint.
>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> When H aborts this call to itself made by P then P never
>>>>>>>>>>>>> reaches
>>>>>>>>>>>>> its final state. If H never aborts this call made by P then
>>>>>>>>>>>>> P never
>>>>>>>>>>>>> reaches its final state. This conclusively proves that H
>>>>>>>>>>>>> can abort
>>>>>>>>>>>>> this call to itself and report that its input never halts.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> But it doensn't matter that H's PARTIAL simulation of P
>>>>>>>>>>>> reached the
>>>>>>>>>>>> halting point. When we run the actual computation, or give
>>>>>>>>>>>> this input
>>>>>>>>>>>> to a REAL pure simulator, it will Halt.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Here is the reference to my NumParams system:
>>>>>>>>>>>>> On 10/23/2021 8:27 PM, olcott wrote:
>>>>>>>>>>>>> [I finally completed my lexical analyzer generator (needed
>>>>>>>>>>>>> by my
>>>>>>>>>>>>> halt decider)]
>>>>>>>>>>>>> This system uses a DFA lexical analyzer to recognize
>>>>>>>>>>>>> the pattern of function declarations. This pattern is
>>>>>>>>>>>>> specified as 15 DFA states. The output is a C header
>>>>>>>>>>>>> file that looks up the function name specified in the
>>>>>>>>>>>>> COFF object file and returns its number of parameters.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> And where does this code get the source code of the program
>>>>>>>>>>>> whose
>>>>>>>>>>>> COMPILED form has been given to H?
>>>>>>>>>>>>
>>>>>>>>>>>> Or, is H now being given the source code as the representation?
>>>>>>>>>>>>
>>>>>>>>>>>> Remember, if you do that, then that source code needs to
>>>>>>>>>>>> contain the
>>>>>>>>>>>> FULL description of the program, which includes the code for
>>>>>>>>>>>> H, and
>>>>>>>>>>>> everything it uses, which includes your NumParams and the
>>>>>>>>>>>> compiler
>>>>>>>>>>>> you are going to put that code into.
>>>>>>>>>>>
>>>>>>>>>>> Nope, H needs to be a black box so its implementation is
>>>>>>>>>>> unknown to
>>>>>>>>>>> everyone but the creator of H.  If H is a black box it can
>>>>>>>>>>> safely
>>>>>>>>>>> detect recursion into it and signal an exception.
>>>>>>>>>>
>>>>>>>>>> That won't work because someone could write the same H as a
>>>>>>>>>> whitebox.
>>>>>>>>>>
>>>>>>>>>> Here is my current enormously simplified proof:
>>>>>>>>>> Does the call from P() to H() specify infinite recursion?
>>>>>>>>>>
>>>>>>>>>> #define ptr uintptr_t
>>>>>>>>>>
>>>>>>>>>> void P(ptr x)
>>>>>>>>>> {
>>>>>>>>>>    H(x, x);
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> int H(ptr x, ptr y)
>>>>>>>>>> {
>>>>>>>>>>    ((void(*)(ptr))x)(y);
>>>>>>>>>>    return 1;
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> int main()
>>>>>>>>>> {
>>>>>>>>>>    H((ptr)P, (ptr)P);
>>>>>>>>>>    return 0;
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> Yes it does.
>>>>>>>>>>
>>>>>>>>>> _P()
>>>>>>>>>> [00001a5e](01)  55              push ebp
>>>>>>>>>> [00001a5f](02)  8bec            mov ebp,esp
>>>>>>>>>> [00001a61](03)  8b4508          mov eax,[ebp+08]
>>>>>>>>>> [00001a64](01)  50              push eax        // push P
>>>>>>>>>> [00001a65](03)  8b4d08          mov ecx,[ebp+08]
>>>>>>>>>> [00001a68](01)  51              push ecx        // push P
>>>>>>>>>> [00001a69](05)  e810000000      call 00001a7e   // call H
>>>>>>>>>> [00001a6e](03)  83c408          add esp,+08
>>>>>>>>>> [00001a71](01)  5d              pop ebp
>>>>>>>>>> [00001a72](01)  c3              ret
>>>>>>>>>> Size in bytes:(0021) [00001a72]
>>>>>>>>
>>>>>>>>
>>>>>>>> YOU TOTALLY IGNORED ALL OF THESE NEXT WORDS
>>>>>>>> YOU TOTALLY IGNORED ALL OF THESE NEXT WORDS
>>>>>>>> YOU TOTALLY IGNORED ALL OF THESE NEXT WORDS
>>>>>>>> YOU TOTALLY IGNORED ALL OF THESE NEXT WORDS
>>>>>>>
>>>>>>> You can not use the 'proof' for the H that doesn't abort for the
>>>>>>> H that does, they are different Hs and create different Ps.
>>>>>> If in every H in the universe P never halts then P never halts.
>>>>>>
>>>>>>
>>>>>
>>>>> Except most do.
>>>>>
>>>>> For Any H that returns the value of 0 from H(P,P), then P(P) will
>>>>> halt.
>>>>>
>>>>
>>>> For every H in the universe no P ever reaches its machine code
>>>> address of 1a72, thus no P ever halts.
>>>
>>> Except that you are too dumb to realize that they do. They may not
>>> reach that point in the PARTIAL simulation that H does, but they do
>>> in the REAL simulation by a proper PURE simulation, or by the direct
>>> running of the machine.
>> Ben did an absolutely brilliant job of simplifying the syntax of my
>> code. Perhaps you can comprehend that the printf is never reached?
>
> Except that doesn't matter.
>


Click here to read the complete article
Re: Olcott wrong about infinite recursion [ simplest rebuttal of halting theorem ] [ Ben's changes ]

<3JhjJ.16204$b%.2566@fx24.iad>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=23366&group=comp.theory#23366

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!feeder1.feed.usenet.farm!feed.usenet.farm!peer01.ams4!peer.am4.highwinds-media.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx24.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.3.0
Subject: Re: Olcott wrong about infinite recursion [ simplest rebuttal of
halting theorem ] [ Ben's changes ]
Content-Language: en-US
Newsgroups: comp.theory
References: <20211110215316.0000221e@reddwarf.jmc>
<ApydnX6D6fN31RH8nZ2dnUU7-UXNnZ2d@giganews.com>
<PFZiJ.19745$cW6.10169@fx08.iad> <20211111175240.00000a3b@reddwarf.jmc>
<upSdnfNv4q1S8RD8nZ2dnUU7-WXNnZ2d@giganews.com>
<rdejJ.20399$SW5.15061@fx45.iad>
<tIqdncrf0fM86xD8nZ2dnUU7-XednZ2d@giganews.com>
<NZejJ.21674$SW5.667@fx45.iad>
<hL6dnfx6kfTkHBD8nZ2dnUU7-ROdnZ2d@giganews.com>
<PNfjJ.21676$SW5.20549@fx45.iad>
<CpidnX-XCpQlEBD8nZ2dnUU7-QWdnZ2d@giganews.com>
<lAgjJ.30976$3q9.23015@fx47.iad>
<jtadnVpTvr8HABD8nZ2dnUU7-d_NnZ2d@giganews.com>
<ahhjJ.16203$b%.15269@fx24.iad>
<-JOdnabQjsW9PhD8nZ2dnUU7-W3NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <-JOdnabQjsW9PhD8nZ2dnUU7-W3NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 273
Message-ID: <3JhjJ.16204$b%.2566@fx24.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Thu, 11 Nov 2021 18:31:11 -0500
X-Received-Bytes: 12054
 by: Richard Damon - Thu, 11 Nov 2021 23:31 UTC

On 11/11/21 6:11 PM, olcott wrote:
> On 11/11/2021 5:01 PM, Richard Damon wrote:
>> On 11/11/21 5:47 PM, olcott wrote:
>>> On 11/11/2021 4:13 PM, Richard Damon wrote:
>>>> On 11/11/21 4:40 PM, olcott wrote:
>>>>> On 11/11/2021 3:19 PM, Richard Damon wrote:
>>>>>> On 11/11/21 3:47 PM, olcott wrote:
>>>>>>> On 11/11/2021 2:24 PM, Richard Damon wrote:
>>>>>>>> On 11/11/21 3:01 PM, olcott wrote:
>>>>>>>>> On 11/11/2021 1:32 PM, Richard Damon wrote:
>>>>>>>>>>
>>>>>>>>>> On 11/11/21 2:19 PM, olcott wrote:
>>>>>>>>>>> On 11/11/2021 11:52 AM, Mr Flibble wrote:
>>>>>>>>>>>> On Wed, 10 Nov 2021 19:42:23 -0500
>>>>>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>>>>>>
>>>>>>>>>>>>> On 11/10/21 5:34 PM, olcott wrote:
>>>>>>>>>>>>>> On 11/10/2021 3:53 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>> Olcott is barking up the wrong tree re infinite
>>>>>>>>>>>>>>> recursion: there
>>>>>>>>>>>>>>> is only a need to detect a single recursive call into the
>>>>>>>>>>>>>>> halt
>>>>>>>>>>>>>>> decider and signal an exception.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Yes, I figured that out. That eliminates the need for
>>>>>>>>>>>>>> static local
>>>>>>>>>>>>>> data thus allowing the halt decider to be a pure function.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Except that this logic is only correct if the function is
>>>>>>>>>>>>> being
>>>>>>>>>>>>> executed under unconditional execution.
>>>>>>>>>>>>>
>>>>>>>>>>>>> If the 'simulation' is being run under condition that can/will
>>>>>>>>>>>>> terminate its execution, then the detection of this
>>>>>>>>>>>>> recursion is NOT
>>>>>>>>>>>>> proof that the execution will be non-halting.
>>>>>>>>>>>>>
>>>>>>>>>>>>> All you have show is that IF the decider would never abort its
>>>>>>>>>>>>> 'simulation' then the program would be non-halting.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Since it turns out that the decider DOES abort its
>>>>>>>>>>>>> 'simulation', the
>>>>>>>>>>>>> assumptions that the analysis was done under are not in
>>>>>>>>>>>>> fact true, so
>>>>>>>>>>>>> the analysis is invalid.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Pure_function
>>>>>>>>>>>>>
>>>>>>>>>>>>> But Software Engineering 'Pure Function' is NOT the
>>>>>>>>>>>>> Compution Theory
>>>>>>>>>>>>> 'Computation', so you need to be aware of the difference.
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> That is why I needed my source-code analyzer to provide
>>>>>>>>>>>>>> the exact
>>>>>>>>>>>>>> number of parameters to every function.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> As long as the currently executing function (H) is called
>>>>>>>>>>>>>> again
>>>>>>>>>>>>>> with the same parameters then we know that this call will be
>>>>>>>>>>>>>> infinitely recursive unless this infinite recursion is
>>>>>>>>>>>>>> aborted at
>>>>>>>>>>>>>> some point.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Right, it would be infinite if NEVER aborted, but it IS
>>>>>>>>>>>>> aborted, so
>>>>>>>>>>>>> it is not infinite, and since the machine uses a copy of
>>>>>>>>>>>>> the decider,
>>>>>>>>>>>>> that same fact applies to it being run as an indepent
>>>>>>>>>>>>> computation,
>>>>>>>>>>>>> since the decider inside it does abort its internal
>>>>>>>>>>>>> simulation, it
>>>>>>>>>>>>> return the answer that allows the actual computation to be
>>>>>>>>>>>>> finint.
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> When H aborts this call to itself made by P then P never
>>>>>>>>>>>>>> reaches
>>>>>>>>>>>>>> its final state. If H never aborts this call made by P
>>>>>>>>>>>>>> then P never
>>>>>>>>>>>>>> reaches its final state. This conclusively proves that H
>>>>>>>>>>>>>> can abort
>>>>>>>>>>>>>> this call to itself and report that its input never halts.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> But it doensn't matter that H's PARTIAL simulation of P
>>>>>>>>>>>>> reached the
>>>>>>>>>>>>> halting point. When we run the actual computation, or give
>>>>>>>>>>>>> this input
>>>>>>>>>>>>> to a REAL pure simulator, it will Halt.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Here is the reference to my NumParams system:
>>>>>>>>>>>>>> On 10/23/2021 8:27 PM, olcott wrote:
>>>>>>>>>>>>>> [I finally completed my lexical analyzer generator (needed
>>>>>>>>>>>>>> by my
>>>>>>>>>>>>>> halt decider)]
>>>>>>>>>>>>>> This system uses a DFA lexical analyzer to recognize
>>>>>>>>>>>>>> the pattern of function declarations. This pattern is
>>>>>>>>>>>>>> specified as 15 DFA states. The output is a C header
>>>>>>>>>>>>>> file that looks up the function name specified in the
>>>>>>>>>>>>>> COFF object file and returns its number of parameters.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> And where does this code get the source code of the program
>>>>>>>>>>>>> whose
>>>>>>>>>>>>> COMPILED form has been given to H?
>>>>>>>>>>>>>
>>>>>>>>>>>>> Or, is H now being given the source code as the
>>>>>>>>>>>>> representation?
>>>>>>>>>>>>>
>>>>>>>>>>>>> Remember, if you do that, then that source code needs to
>>>>>>>>>>>>> contain the
>>>>>>>>>>>>> FULL description of the program, which includes the code
>>>>>>>>>>>>> for H, and
>>>>>>>>>>>>> everything it uses, which includes your NumParams and the
>>>>>>>>>>>>> compiler
>>>>>>>>>>>>> you are going to put that code into.
>>>>>>>>>>>>
>>>>>>>>>>>> Nope, H needs to be a black box so its implementation is
>>>>>>>>>>>> unknown to
>>>>>>>>>>>> everyone but the creator of H.  If H is a black box it can
>>>>>>>>>>>> safely
>>>>>>>>>>>> detect recursion into it and signal an exception.
>>>>>>>>>>>
>>>>>>>>>>> That won't work because someone could write the same H as a
>>>>>>>>>>> whitebox.
>>>>>>>>>>>
>>>>>>>>>>> Here is my current enormously simplified proof:
>>>>>>>>>>> Does the call from P() to H() specify infinite recursion?
>>>>>>>>>>>
>>>>>>>>>>> #define ptr uintptr_t
>>>>>>>>>>>
>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>> {
>>>>>>>>>>>    H(x, x);
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> int H(ptr x, ptr y)
>>>>>>>>>>> {
>>>>>>>>>>>    ((void(*)(ptr))x)(y);
>>>>>>>>>>>    return 1;
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> int main()
>>>>>>>>>>> {
>>>>>>>>>>>    H((ptr)P, (ptr)P);
>>>>>>>>>>>    return 0;
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> Yes it does.
>>>>>>>>>>>
>>>>>>>>>>> _P()
>>>>>>>>>>> [00001a5e](01)  55              push ebp
>>>>>>>>>>> [00001a5f](02)  8bec            mov ebp,esp
>>>>>>>>>>> [00001a61](03)  8b4508          mov eax,[ebp+08]
>>>>>>>>>>> [00001a64](01)  50              push eax        // push P
>>>>>>>>>>> [00001a65](03)  8b4d08          mov ecx,[ebp+08]
>>>>>>>>>>> [00001a68](01)  51              push ecx        // push P
>>>>>>>>>>> [00001a69](05)  e810000000      call 00001a7e   // call H
>>>>>>>>>>> [00001a6e](03)  83c408          add esp,+08
>>>>>>>>>>> [00001a71](01)  5d              pop ebp
>>>>>>>>>>> [00001a72](01)  c3              ret
>>>>>>>>>>> Size in bytes:(0021) [00001a72]
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> YOU TOTALLY IGNORED ALL OF THESE NEXT WORDS
>>>>>>>>> YOU TOTALLY IGNORED ALL OF THESE NEXT WORDS
>>>>>>>>> YOU TOTALLY IGNORED ALL OF THESE NEXT WORDS
>>>>>>>>> YOU TOTALLY IGNORED ALL OF THESE NEXT WORDS
>>>>>>>>
>>>>>>>> You can not use the 'proof' for the H that doesn't abort for the
>>>>>>>> H that does, they are different Hs and create different Ps.
>>>>>>> If in every H in the universe P never halts then P never halts.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> Except most do.
>>>>>>
>>>>>> For Any H that returns the value of 0 from H(P,P), then P(P) will
>>>>>> halt.
>>>>>>
>>>>>
>>>>> For every H in the universe no P ever reaches its machine code
>>>>> address of 1a72, thus no P ever halts.
>>>>
>>>> Except that you are too dumb to realize that they do. They may not
>>>> reach that point in the PARTIAL simulation that H does, but they do
>>>> in the REAL simulation by a proper PURE simulation, or by the direct
>>>> running of the machine.
>>> Ben did an absolutely brilliant job of simplifying the syntax of my
>>> code. Perhaps you can comprehend that the printf is never reached?
>>
>> Except that doesn't matter.
>>
>
> It totally matters you claimed that P reaches its machine address of 1a72


Click here to read the complete article
Re: Olcott wrong about infinite recursion [ simplest rebuttal of halting theorem ] [ Ben's changes ]

<Ztqdnd_gcOaMMhD8nZ2dnUU7-Q-dnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=23370&group=comp.theory#23370

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!paganini.bofh.team!news.dns-netz.com!news.freedyn.net!newsfeed.xs4all.nl!newsfeed9.news.xs4all.nl!tr2.eu1.usenetexpress.com!feeder.usenetexpress.com!tr1.iad1.usenetexpress.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Thu, 11 Nov 2021 18:02:25 -0600
Date: Thu, 11 Nov 2021 18:02:23 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101 Thunderbird/91.3.0
Subject: Re: Olcott wrong about infinite recursion [ simplest rebuttal of halting theorem ] [ Ben's changes ]
Content-Language: en-US
Newsgroups: comp.theory
References: <20211110215316.0000221e@reddwarf.jmc> <ApydnX6D6fN31RH8nZ2dnUU7-UXNnZ2d@giganews.com> <PFZiJ.19745$cW6.10169@fx08.iad> <20211111175240.00000a3b@reddwarf.jmc> <upSdnfNv4q1S8RD8nZ2dnUU7-WXNnZ2d@giganews.com> <rdejJ.20399$SW5.15061@fx45.iad> <tIqdncrf0fM86xD8nZ2dnUU7-XednZ2d@giganews.com> <NZejJ.21674$SW5.667@fx45.iad> <hL6dnfx6kfTkHBD8nZ2dnUU7-ROdnZ2d@giganews.com> <PNfjJ.21676$SW5.20549@fx45.iad> <CpidnX-XCpQlEBD8nZ2dnUU7-QWdnZ2d@giganews.com> <lAgjJ.30976$3q9.23015@fx47.iad> <jtadnVpTvr8HABD8nZ2dnUU7-d_NnZ2d@giganews.com> <ahhjJ.16203$b%.15269@fx24.iad> <-JOdnabQjsW9PhD8nZ2dnUU7-W3NnZ2d@giganews.com> <3JhjJ.16204$b%.2566@fx24.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <3JhjJ.16204$b%.2566@fx24.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <Ztqdnd_gcOaMMhD8nZ2dnUU7-Q-dnZ2d@giganews.com>
Lines: 233
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-5s5bYIZcsXO7s7zvXX3sgNQtBJ3eEN2ZNbcytLspyVJ8JhV/Kx8e0aaEm41mf4dQEGqMAFRUpFOPYDv!V6/F/UnKRkPNwfUQMauV4wpMOCIQhzH0Xev5LsPfRJ0xfIuAEKdc0Xtf6Vlx8GiSupFKcinXJind!9g==
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 11465
 by: olcott - Fri, 12 Nov 2021 00:02 UTC

On 11/11/2021 5:31 PM, Richard Damon wrote:
> On 11/11/21 6:11 PM, olcott wrote:
>> On 11/11/2021 5:01 PM, Richard Damon wrote:
>>> On 11/11/21 5:47 PM, olcott wrote:
>>>> On 11/11/2021 4:13 PM, Richard Damon wrote:
>>>>> On 11/11/21 4:40 PM, olcott wrote:
>>>>>> On 11/11/2021 3:19 PM, Richard Damon wrote:
>>>>>>> On 11/11/21 3:47 PM, olcott wrote:
>>>>>>>> On 11/11/2021 2:24 PM, Richard Damon wrote:
>>>>>>>>> On 11/11/21 3:01 PM, olcott wrote:
>>>>>>>>>> On 11/11/2021 1:32 PM, Richard Damon wrote:
>>>>>>>>>>>
>>>>>>>>>>> On 11/11/21 2:19 PM, olcott wrote:
>>>>>>>>>>>> On 11/11/2021 11:52 AM, Mr Flibble wrote:
>>>>>>>>>>>>> On Wed, 10 Nov 2021 19:42:23 -0500
>>>>>>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 11/10/21 5:34 PM, olcott wrote:
>>>>>>>>>>>>>>> On 11/10/2021 3:53 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>> Olcott is barking up the wrong tree re infinite
>>>>>>>>>>>>>>>> recursion: there
>>>>>>>>>>>>>>>> is only a need to detect a single recursive call into
>>>>>>>>>>>>>>>> the halt
>>>>>>>>>>>>>>>> decider and signal an exception.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Yes, I figured that out. That eliminates the need for
>>>>>>>>>>>>>>> static local
>>>>>>>>>>>>>>> data thus allowing the halt decider to be a pure function.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Except that this logic is only correct if the function is
>>>>>>>>>>>>>> being
>>>>>>>>>>>>>> executed under unconditional execution.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> If the 'simulation' is being run under condition that
>>>>>>>>>>>>>> can/will
>>>>>>>>>>>>>> terminate its execution, then the detection of this
>>>>>>>>>>>>>> recursion is NOT
>>>>>>>>>>>>>> proof that the execution will be non-halting.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> All you have show is that IF the decider would never abort
>>>>>>>>>>>>>> its
>>>>>>>>>>>>>> 'simulation' then the program would be non-halting.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Since it turns out that the decider DOES abort its
>>>>>>>>>>>>>> 'simulation', the
>>>>>>>>>>>>>> assumptions that the analysis was done under are not in
>>>>>>>>>>>>>> fact true, so
>>>>>>>>>>>>>> the analysis is invalid.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Pure_function
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> But Software Engineering 'Pure Function' is NOT the
>>>>>>>>>>>>>> Compution Theory
>>>>>>>>>>>>>> 'Computation', so you need to be aware of the difference.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> That is why I needed my source-code analyzer to provide
>>>>>>>>>>>>>>> the exact
>>>>>>>>>>>>>>> number of parameters to every function.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> As long as the currently executing function (H) is called
>>>>>>>>>>>>>>> again
>>>>>>>>>>>>>>> with the same parameters then we know that this call will be
>>>>>>>>>>>>>>> infinitely recursive unless this infinite recursion is
>>>>>>>>>>>>>>> aborted at
>>>>>>>>>>>>>>> some point.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Right, it would be infinite if NEVER aborted, but it IS
>>>>>>>>>>>>>> aborted, so
>>>>>>>>>>>>>> it is not infinite, and since the machine uses a copy of
>>>>>>>>>>>>>> the decider,
>>>>>>>>>>>>>> that same fact applies to it being run as an indepent
>>>>>>>>>>>>>> computation,
>>>>>>>>>>>>>> since the decider inside it does abort its internal
>>>>>>>>>>>>>> simulation, it
>>>>>>>>>>>>>> return the answer that allows the actual computation to be
>>>>>>>>>>>>>> finint.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> When H aborts this call to itself made by P then P never
>>>>>>>>>>>>>>> reaches
>>>>>>>>>>>>>>> its final state. If H never aborts this call made by P
>>>>>>>>>>>>>>> then P never
>>>>>>>>>>>>>>> reaches its final state. This conclusively proves that H
>>>>>>>>>>>>>>> can abort
>>>>>>>>>>>>>>> this call to itself and report that its input never halts.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> But it doensn't matter that H's PARTIAL simulation of P
>>>>>>>>>>>>>> reached the
>>>>>>>>>>>>>> halting point. When we run the actual computation, or give
>>>>>>>>>>>>>> this input
>>>>>>>>>>>>>> to a REAL pure simulator, it will Halt.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Here is the reference to my NumParams system:
>>>>>>>>>>>>>>> On 10/23/2021 8:27 PM, olcott wrote:
>>>>>>>>>>>>>>> [I finally completed my lexical analyzer generator
>>>>>>>>>>>>>>> (needed by my
>>>>>>>>>>>>>>> halt decider)]
>>>>>>>>>>>>>>> This system uses a DFA lexical analyzer to recognize
>>>>>>>>>>>>>>> the pattern of function declarations. This pattern is
>>>>>>>>>>>>>>> specified as 15 DFA states. The output is a C header
>>>>>>>>>>>>>>> file that looks up the function name specified in the
>>>>>>>>>>>>>>> COFF object file and returns its number of parameters.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> And where does this code get the source code of the
>>>>>>>>>>>>>> program whose
>>>>>>>>>>>>>> COMPILED form has been given to H?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Or, is H now being given the source code as the
>>>>>>>>>>>>>> representation?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Remember, if you do that, then that source code needs to
>>>>>>>>>>>>>> contain the
>>>>>>>>>>>>>> FULL description of the program, which includes the code
>>>>>>>>>>>>>> for H, and
>>>>>>>>>>>>>> everything it uses, which includes your NumParams and the
>>>>>>>>>>>>>> compiler
>>>>>>>>>>>>>> you are going to put that code into.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Nope, H needs to be a black box so its implementation is
>>>>>>>>>>>>> unknown to
>>>>>>>>>>>>> everyone but the creator of H.  If H is a black box it can
>>>>>>>>>>>>> safely
>>>>>>>>>>>>> detect recursion into it and signal an exception.
>>>>>>>>>>>>
>>>>>>>>>>>> That won't work because someone could write the same H as a
>>>>>>>>>>>> whitebox.
>>>>>>>>>>>>
>>>>>>>>>>>> Here is my current enormously simplified proof:
>>>>>>>>>>>> Does the call from P() to H() specify infinite recursion?
>>>>>>>>>>>>
>>>>>>>>>>>> #define ptr uintptr_t
>>>>>>>>>>>>
>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>> {
>>>>>>>>>>>>    H(x, x);
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> int H(ptr x, ptr y)
>>>>>>>>>>>> {
>>>>>>>>>>>>    ((void(*)(ptr))x)(y);
>>>>>>>>>>>>    return 1;
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> int main()
>>>>>>>>>>>> {
>>>>>>>>>>>>    H((ptr)P, (ptr)P);
>>>>>>>>>>>>    return 0;
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> Yes it does.
>>>>>>>>>>>>
>>>>>>>>>>>> _P()
>>>>>>>>>>>> [00001a5e](01)  55              push ebp
>>>>>>>>>>>> [00001a5f](02)  8bec            mov ebp,esp
>>>>>>>>>>>> [00001a61](03)  8b4508          mov eax,[ebp+08]
>>>>>>>>>>>> [00001a64](01)  50              push eax        // push P
>>>>>>>>>>>> [00001a65](03)  8b4d08          mov ecx,[ebp+08]
>>>>>>>>>>>> [00001a68](01)  51              push ecx        // push P
>>>>>>>>>>>> [00001a69](05)  e810000000      call 00001a7e   // call H
>>>>>>>>>>>> [00001a6e](03)  83c408          add esp,+08
>>>>>>>>>>>> [00001a71](01)  5d              pop ebp
>>>>>>>>>>>> [00001a72](01)  c3              ret
>>>>>>>>>>>> Size in bytes:(0021) [00001a72]
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> YOU TOTALLY IGNORED ALL OF THESE NEXT WORDS
>>>>>>>>>> YOU TOTALLY IGNORED ALL OF THESE NEXT WORDS
>>>>>>>>>> YOU TOTALLY IGNORED ALL OF THESE NEXT WORDS
>>>>>>>>>> YOU TOTALLY IGNORED ALL OF THESE NEXT WORDS
>>>>>>>>>
>>>>>>>>> You can not use the 'proof' for the H that doesn't abort for
>>>>>>>>> the H that does, they are different Hs and create different Ps.
>>>>>>>> If in every H in the universe P never halts then P never halts.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> Except most do.
>>>>>>>
>>>>>>> For Any H that returns the value of 0 from H(P,P), then P(P) will
>>>>>>> halt.
>>>>>>>
>>>>>>
>>>>>> For every H in the universe no P ever reaches its machine code
>>>>>> address of 1a72, thus no P ever halts.
>>>>>
>>>>> Except that you are too dumb to realize that they do. They may not
>>>>> reach that point in the PARTIAL simulation that H does, but they do
>>>>> in the REAL simulation by a proper PURE simulation, or by the
>>>>> direct running of the machine.
>>>> Ben did an absolutely brilliant job of simplifying the syntax of my
>>>> code. Perhaps you can comprehend that the printf is never reached?
>>>
>>> Except that doesn't matter.
>>>
>>
>> It totally matters you claimed that P reaches its machine address of 1a72
>
> No, It does NOT matter what happens in the simulation inside H, what
> matters is what the actual machine does.
>
> You don't know the meaning of the words.
>
>>
>>  >>> in the REAL simulation by a proper PURE simulation, or by the direct
>>  >>> running of the machine.
>>
>> I have proven this is pure bullshit and you said that my proof doesn't
>> matter. This is dishonesty is the reason why I usually ignore most of
>> your posts.
>
> No, you haven't. You use wrong words to try to claim it, but you are
> wrong, BY DEFINITION.
>


Click here to read the complete article
Re: Olcott wrong about infinite recursion [ simplest rebuttal of halting theorem ] [ Ben's changes ]

<FrijJ.21678$SW5.4872@fx45.iad>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=23371&group=comp.theory#23371

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!paganini.bofh.team!news.dns-netz.com!news.freedyn.net!newsreader4.netcologne.de!news.netcologne.de!peer01.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx45.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.3.0
Subject: Re: Olcott wrong about infinite recursion [ simplest rebuttal of
halting theorem ] [ Ben's changes ]
Content-Language: en-US
Newsgroups: comp.theory
References: <20211110215316.0000221e@reddwarf.jmc>
<ApydnX6D6fN31RH8nZ2dnUU7-UXNnZ2d@giganews.com>
<PFZiJ.19745$cW6.10169@fx08.iad> <20211111175240.00000a3b@reddwarf.jmc>
<upSdnfNv4q1S8RD8nZ2dnUU7-WXNnZ2d@giganews.com>
<rdejJ.20399$SW5.15061@fx45.iad>
<tIqdncrf0fM86xD8nZ2dnUU7-XednZ2d@giganews.com>
<NZejJ.21674$SW5.667@fx45.iad>
<hL6dnfx6kfTkHBD8nZ2dnUU7-ROdnZ2d@giganews.com>
<PNfjJ.21676$SW5.20549@fx45.iad>
<CpidnX-XCpQlEBD8nZ2dnUU7-QWdnZ2d@giganews.com>
<lAgjJ.30976$3q9.23015@fx47.iad>
<jtadnVpTvr8HABD8nZ2dnUU7-d_NnZ2d@giganews.com>
<ahhjJ.16203$b%.15269@fx24.iad>
<-JOdnabQjsW9PhD8nZ2dnUU7-W3NnZ2d@giganews.com>
<3JhjJ.16204$b%.2566@fx24.iad>
<Ztqdnd_gcOaMMhD8nZ2dnUU7-Q-dnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <Ztqdnd_gcOaMMhD8nZ2dnUU7-Q-dnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Lines: 59
Message-ID: <FrijJ.21678$SW5.4872@fx45.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Thu, 11 Nov 2021 19:20:52 -0500
X-Received-Bytes: 3209
 by: Richard Damon - Fri, 12 Nov 2021 00:20 UTC

On 11/11/21 7:02 PM, olcott wrote:

> I say that P never reaches 1a72.
> You say that it does.
> I prove that it doesn't
> You say that my proof doesn't matter
>
> That behavior matches the pattern of a liar.
>

Ok, so your claim now is that that Direct Execution of P(P) never
reaches 1A72?

Even though you have previously admitted it does?

What is then wrong with this high level trace of the direct execution og
P(P)?

1) Main calles P(P)

2) P then calls H(P,P)

3) H then starts it simulation of P(P)

4) H then simulates P(P) calling H(P,P)
by your new rules:

5) H then sees that P(P) is calling H with the same parameters that it
started with and thus decides that P(P) is non-halting and thus aborts
its simulation and return 0 to the outermost P

6) P Halts.

Ergo, P(P) is, by definition Halting and thus the right answer that
H(P,P) needs to return to be right is Halting (1)

By your old rules:

5) H then simulates the simulation of P(P)

6) H then simulates the simulation of P calling H(P,P)

7) H then sees that there are two calls of H(P,P) in the loop and then
aborts its simulation and return 0 to the outermost P

8) P Halts.

Again, P(P) is shown by definition to be a halting computation and the
right answer for H(P,P) to return would have been 1 (Halting)

So Who is lying now?

Remember, you have previously AGREED that P(P) was halting but that
somehow non-halting was the right answer, but could actually never prove
it since that isn't true.

Re: Olcott wrong about infinite recursion [ simplest rebuttal of halting theorem ] [ Ben's changes ]

<7tGdnZfKlojRJxD8nZ2dnUU7-UWdnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=23373&group=comp.theory#23373

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!news.dns-netz.com!news.freedyn.net!newsfeed.xs4all.nl!newsfeed9.news.xs4all.nl!tr1.eu1.usenetexpress.com!feeder.usenetexpress.com!tr3.iad1.usenetexpress.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Thu, 11 Nov 2021 18:50:20 -0600
Date: Thu, 11 Nov 2021 18:50:18 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101 Thunderbird/91.3.0
Subject: Re: Olcott wrong about infinite recursion [ simplest rebuttal of halting theorem ] [ Ben's changes ]
Content-Language: en-US
Newsgroups: comp.theory
References: <20211110215316.0000221e@reddwarf.jmc> <ApydnX6D6fN31RH8nZ2dnUU7-UXNnZ2d@giganews.com> <PFZiJ.19745$cW6.10169@fx08.iad> <20211111175240.00000a3b@reddwarf.jmc> <upSdnfNv4q1S8RD8nZ2dnUU7-WXNnZ2d@giganews.com> <rdejJ.20399$SW5.15061@fx45.iad> <tIqdncrf0fM86xD8nZ2dnUU7-XednZ2d@giganews.com> <NZejJ.21674$SW5.667@fx45.iad> <hL6dnfx6kfTkHBD8nZ2dnUU7-ROdnZ2d@giganews.com> <PNfjJ.21676$SW5.20549@fx45.iad> <CpidnX-XCpQlEBD8nZ2dnUU7-QWdnZ2d@giganews.com> <lAgjJ.30976$3q9.23015@fx47.iad> <jtadnVpTvr8HABD8nZ2dnUU7-d_NnZ2d@giganews.com> <ahhjJ.16203$b%.15269@fx24.iad> <-JOdnabQjsW9PhD8nZ2dnUU7-W3NnZ2d@giganews.com> <3JhjJ.16204$b%.2566@fx24.iad> <Ztqdnd_gcOaMMhD8nZ2dnUU7-Q-dnZ2d@giganews.com> <FrijJ.21678$SW5.4872@fx45.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <FrijJ.21678$SW5.4872@fx45.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <7tGdnZfKlojRJxD8nZ2dnUU7-UWdnZ2d@giganews.com>
Lines: 25
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-XT3UcEsebvsD8tZ8xF8uSxRNYTi1WJB7OIIzQPv7+2klwgHPqikSLmWE0pUYTmQtKLLepy+QCCb7nsG!G92XDyTaJnFWpIdsH9WR1PYDMSk/QGLX6JWTBXTVT0iBfE3yoCDwT4oah5ZGtSVp7zAFIWS9v1Gq!dg==
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 2535
 by: olcott - Fri, 12 Nov 2021 00:50 UTC

On 11/11/2021 6:20 PM, Richard Damon wrote:
>
> On 11/11/21 7:02 PM, olcott wrote:
>
>> I say that P never reaches 1a72.
>> You say that it does.
>> I prove that it doesn't
>> You say that my proof doesn't matter
>>
>> That behavior matches the pattern of a liar.
>>
>
> Ok, so your claim now is that that Direct Execution of P(P) never
> reaches 1A72?
>

If under every circumstance P never reaches 1a72 then P never halts.

--
Copyright 2021 Pete Olcott

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

Re: Olcott wrong about infinite recursion [ simplest rebuttal of halting theorem ] [ Ben's changes ]

<uPjjJ.11533$xe2.10934@fx16.iad>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=23375&group=comp.theory#23375

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!feeder1.feed.usenet.farm!feed.usenet.farm!peer02.ams4!peer.am4.highwinds-media.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx16.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.3.0
Subject: Re: Olcott wrong about infinite recursion [ simplest rebuttal of
halting theorem ] [ Ben's changes ]
Content-Language: en-US
Newsgroups: comp.theory
References: <20211110215316.0000221e@reddwarf.jmc>
<ApydnX6D6fN31RH8nZ2dnUU7-UXNnZ2d@giganews.com>
<PFZiJ.19745$cW6.10169@fx08.iad> <20211111175240.00000a3b@reddwarf.jmc>
<upSdnfNv4q1S8RD8nZ2dnUU7-WXNnZ2d@giganews.com>
<rdejJ.20399$SW5.15061@fx45.iad>
<tIqdncrf0fM86xD8nZ2dnUU7-XednZ2d@giganews.com>
<NZejJ.21674$SW5.667@fx45.iad>
<hL6dnfx6kfTkHBD8nZ2dnUU7-ROdnZ2d@giganews.com>
<PNfjJ.21676$SW5.20549@fx45.iad>
<CpidnX-XCpQlEBD8nZ2dnUU7-QWdnZ2d@giganews.com>
<lAgjJ.30976$3q9.23015@fx47.iad>
<jtadnVpTvr8HABD8nZ2dnUU7-d_NnZ2d@giganews.com>
<ahhjJ.16203$b%.15269@fx24.iad>
<-JOdnabQjsW9PhD8nZ2dnUU7-W3NnZ2d@giganews.com>
<3JhjJ.16204$b%.2566@fx24.iad>
<Ztqdnd_gcOaMMhD8nZ2dnUU7-Q-dnZ2d@giganews.com>
<FrijJ.21678$SW5.4872@fx45.iad>
<7tGdnZfKlojRJxD8nZ2dnUU7-UWdnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <7tGdnZfKlojRJxD8nZ2dnUU7-UWdnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Lines: 36
Message-ID: <uPjjJ.11533$xe2.10934@fx16.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Thu, 11 Nov 2021 20:54:33 -0500
X-Received-Bytes: 2830
 by: Richard Damon - Fri, 12 Nov 2021 01:54 UTC

On 11/11/21 7:50 PM, olcott wrote:
> On 11/11/2021 6:20 PM, Richard Damon wrote:
>>
>> On 11/11/21 7:02 PM, olcott wrote:
>>
>>> I say that P never reaches 1a72.
>>> You say that it does.
>>> I prove that it doesn't
>>> You say that my proof doesn't matter
>>>
>>> That behavior matches the pattern of a liar.
>>>
>>
>> Ok, so your claim now is that that Direct Execution of P(P) never
>> reaches 1A72?
>>
>
> If under every circumstance P never reaches 1a72 then P never halts.
>

Then why did you say prebviously that P(P) does halt?

Where is the error in the trace I previously posted?
Which step does not happen the way I described.

I am calling you out here as a flat out LIAR.

Even if you by your claim you mean only the simulation by H never
reaches that state, your statement above does not say that, so it is a LIE.

Your statement is UNDER EVERY CIRCUMSTANCE, so that includes the direct
running of P(P) for an H that answers H(P,P) with a return of 0 (and if
no H does that then your whole argument is totally vacuous)

FAIL.

Re: Olcott wrong about infinite recursion [ simplest rebuttal of halting theorem ] [ Ben's changes ]

<f6ednbZ3QKAQVhD8nZ2dnUU7-QHNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=23376&group=comp.theory#23376

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!tr3.eu1.usenetexpress.com!feeder.usenetexpress.com!tr1.iad1.usenetexpress.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Thu, 11 Nov 2021 20:03:57 -0600
Date: Thu, 11 Nov 2021 20:03:55 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101 Thunderbird/91.3.0
Subject: Re: Olcott wrong about infinite recursion [ simplest rebuttal of halting theorem ] [ Ben's changes ]
Content-Language: en-US
Newsgroups: comp.theory
References: <20211110215316.0000221e@reddwarf.jmc> <ApydnX6D6fN31RH8nZ2dnUU7-UXNnZ2d@giganews.com> <PFZiJ.19745$cW6.10169@fx08.iad> <20211111175240.00000a3b@reddwarf.jmc> <upSdnfNv4q1S8RD8nZ2dnUU7-WXNnZ2d@giganews.com> <rdejJ.20399$SW5.15061@fx45.iad> <tIqdncrf0fM86xD8nZ2dnUU7-XednZ2d@giganews.com> <NZejJ.21674$SW5.667@fx45.iad> <hL6dnfx6kfTkHBD8nZ2dnUU7-ROdnZ2d@giganews.com> <PNfjJ.21676$SW5.20549@fx45.iad> <CpidnX-XCpQlEBD8nZ2dnUU7-QWdnZ2d@giganews.com> <lAgjJ.30976$3q9.23015@fx47.iad> <jtadnVpTvr8HABD8nZ2dnUU7-d_NnZ2d@giganews.com> <ahhjJ.16203$b%.15269@fx24.iad> <-JOdnabQjsW9PhD8nZ2dnUU7-W3NnZ2d@giganews.com> <3JhjJ.16204$b%.2566@fx24.iad> <Ztqdnd_gcOaMMhD8nZ2dnUU7-Q-dnZ2d@giganews.com> <FrijJ.21678$SW5.4872@fx45.iad> <7tGdnZfKlojRJxD8nZ2dnUU7-UWdnZ2d@giganews.com> <uPjjJ.11533$xe2.10934@fx16.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <uPjjJ.11533$xe2.10934@fx16.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <f6ednbZ3QKAQVhD8nZ2dnUU7-QHNnZ2d@giganews.com>
Lines: 51
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-ImI7+aR0Pt5soBC1X3uJ1vFbzMZrz2gvC/1UVpwNEMGyEk/5wYKlj07Tge0D4odAOfj+NyVfHnrgNbX!uJ/Vg2XFlTK4UcgUtNZB4JRoqNJSqZEnDptGMW20m2NgDyBy2MuQ6bUUEC0ckzfnDcGiFjAiH65R!3g==
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 3645
 by: olcott - Fri, 12 Nov 2021 02:03 UTC

On 11/11/2021 7:54 PM, Richard Damon wrote:
> On 11/11/21 7:50 PM, olcott wrote:
>> On 11/11/2021 6:20 PM, Richard Damon wrote:
>>>
>>> On 11/11/21 7:02 PM, olcott wrote:
>>>
>>>> I say that P never reaches 1a72.
>>>> You say that it does.
>>>> I prove that it doesn't
>>>> You say that my proof doesn't matter
>>>>
>>>> That behavior matches the pattern of a liar.
>>>>
>>>
>>> Ok, so your claim now is that that Direct Execution of P(P) never
>>> reaches 1A72?
>>>
>>
>> If under every circumstance P never reaches 1a72 then P never halts.
>>
>
> Then why did you say prebviously that P(P) does halt?
>

If in the computation H(P,P) P never reaches 1a72 for every H that can
possibly exist and in the computation P reaches 1a72 then these two
computations must be entirely different from each other and able to have
inconsistent behavior relative to each other without contradiction.

> Where is the error in the trace I previously posted?
> Which step does not happen the way I described.
>
> I am calling you out here as a flat out LIAR.
>
> Even if you by your claim you mean only the simulation by H never
> reaches that state, your statement above does not say that, so it is a LIE.
>
> Your statement is UNDER EVERY CIRCUMSTANCE, so that includes the direct
> running of P(P) for an H that answers H(P,P) with a return of 0 (and if
> no H does that then your whole argument is totally vacuous)
>
> FAIL.
>

--
Copyright 2021 Pete Olcott

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

Re: Olcott wrong about infinite recursion [ simplest rebuttal of halting theorem ] [ Ben's changes ]

<ogkjJ.45902$JZ3.6637@fx05.iad>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=23377&group=comp.theory#23377

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!newsreader4.netcologne.de!news.netcologne.de!peer01.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx05.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.3.0
Subject: Re: Olcott wrong about infinite recursion [ simplest rebuttal of
halting theorem ] [ Ben's changes ]
Content-Language: en-US
Newsgroups: comp.theory
References: <20211110215316.0000221e@reddwarf.jmc>
<ApydnX6D6fN31RH8nZ2dnUU7-UXNnZ2d@giganews.com>
<PFZiJ.19745$cW6.10169@fx08.iad> <20211111175240.00000a3b@reddwarf.jmc>
<upSdnfNv4q1S8RD8nZ2dnUU7-WXNnZ2d@giganews.com>
<rdejJ.20399$SW5.15061@fx45.iad>
<tIqdncrf0fM86xD8nZ2dnUU7-XednZ2d@giganews.com>
<NZejJ.21674$SW5.667@fx45.iad>
<hL6dnfx6kfTkHBD8nZ2dnUU7-ROdnZ2d@giganews.com>
<PNfjJ.21676$SW5.20549@fx45.iad>
<CpidnX-XCpQlEBD8nZ2dnUU7-QWdnZ2d@giganews.com>
<lAgjJ.30976$3q9.23015@fx47.iad>
<jtadnVpTvr8HABD8nZ2dnUU7-d_NnZ2d@giganews.com>
<ahhjJ.16203$b%.15269@fx24.iad>
<-JOdnabQjsW9PhD8nZ2dnUU7-W3NnZ2d@giganews.com>
<3JhjJ.16204$b%.2566@fx24.iad>
<Ztqdnd_gcOaMMhD8nZ2dnUU7-Q-dnZ2d@giganews.com>
<FrijJ.21678$SW5.4872@fx45.iad>
<7tGdnZfKlojRJxD8nZ2dnUU7-UWdnZ2d@giganews.com>
<uPjjJ.11533$xe2.10934@fx16.iad>
<f6ednbZ3QKAQVhD8nZ2dnUU7-QHNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <f6ednbZ3QKAQVhD8nZ2dnUU7-QHNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Lines: 90
Message-ID: <ogkjJ.45902$JZ3.6637@fx05.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Thu, 11 Nov 2021 21:25:23 -0500
X-Received-Bytes: 5317
 by: Richard Damon - Fri, 12 Nov 2021 02:25 UTC

On 11/11/21 9:03 PM, olcott wrote:
> On 11/11/2021 7:54 PM, Richard Damon wrote:
>> On 11/11/21 7:50 PM, olcott wrote:
>>> On 11/11/2021 6:20 PM, Richard Damon wrote:
>>>>
>>>> On 11/11/21 7:02 PM, olcott wrote:
>>>>
>>>>> I say that P never reaches 1a72.
>>>>> You say that it does.
>>>>> I prove that it doesn't
>>>>> You say that my proof doesn't matter
>>>>>
>>>>> That behavior matches the pattern of a liar.
>>>>>
>>>>
>>>> Ok, so your claim now is that that Direct Execution of P(P) never
>>>> reaches 1A72?
>>>>
>>>
>>> If under every circumstance P never reaches 1a72 then P never halts.
>>>
>>
>> Then why did you say prebviously that P(P) does halt?
>>
>
> If in the computation H(P,P) P never reaches 1a72 for every H that can
> possibly exist and in the computation P reaches 1a72 then these two
> computations must be entirely different from each other and able to have
> inconsistent behavior relative to each other without contradiction.

The DEFINITION of the problem that H is set to solve is to predict the
behavior of the machine that its input is a representation of [Which
will be the actual computatipn P(P)] which would be the equvalent of
giving the same input as given to H to a real pure simulator like a UTM
which simulates until the computation reaches its end (or simulates
forever if it never will).

If H(P,P) returns 0, then it is easy to see that THAT machine will halt,
and thus ther RIGHT answer that a halt decider deciding on P(P) would by
necessity be Halting (1).

If the compuation inside H(P,P) sees something different, then that is
the fault of the design of H, and could explain why it gets the wrong
answer. It does NOT give H the 'permission' to be wrong but still able
to claim to be right,

Actually, it is well known that the behavior of a partial simulation can
easily differ from the results of an actual pure simulation because a
partial simulation actually never actually indicates the halting
behavior of the machine indicated by its input.

If the conditional simulation actually does reach the end, then the
condition simulation did become a pure simulation, and does prove
halting. If it stops before that point, it didn't prove anything excpet
provide a lower bound for how far the machine will run, whether that
final number is actually finite, and thus Halting, or unbounded and thus
Non-Halting, can't be told from any specific finite bound.

So yes, there is no contradiction between H seeing something different
then the bahavior of the actual machine, but H, to be right, still needs
to give the answer based on the actual machine, not what it sees by
whatever it is doing.

It IS a ERROR (not really a contradiction) to claim that the partial
simulation done by H somehow actually defines what the right answer that
H should produce.

FAIL.

>
>> Where is the error in the trace I previously posted?
>> Which step does not happen the way I described.
>>
>> I am calling you out here as a flat out LIAR.
>>
>> Even if you by your claim you mean only the simulation by H never
>> reaches that state, your statement above does not say that, so it is a
>> LIE.
>>
>> Your statement is UNDER EVERY CIRCUMSTANCE, so that includes the
>> direct running of P(P) for an H that answers H(P,P) with a return of 0
>> (and if no H does that then your whole argument is totally vacuous)
>>
>> FAIL.
>>
>
>

Re: Olcott wrong about infinite recursion [ simplest rebuttal of halting theorem ] [ Ben's changes ]

<s6mdne4JIrg9TBD8nZ2dnUU7-TfNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=23378&group=comp.theory#23378

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!feeder1.feed.usenet.farm!feed.usenet.farm!tr3.eu1.usenetexpress.com!feeder.usenetexpress.com!tr1.iad1.usenetexpress.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Thu, 11 Nov 2021 20:29:52 -0600
Date: Thu, 11 Nov 2021 20:29:49 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101 Thunderbird/91.3.0
Subject: Re: Olcott wrong about infinite recursion [ simplest rebuttal of halting theorem ] [ Ben's changes ]
Content-Language: en-US
Newsgroups: comp.theory
References: <20211110215316.0000221e@reddwarf.jmc> <ApydnX6D6fN31RH8nZ2dnUU7-UXNnZ2d@giganews.com> <PFZiJ.19745$cW6.10169@fx08.iad> <20211111175240.00000a3b@reddwarf.jmc> <upSdnfNv4q1S8RD8nZ2dnUU7-WXNnZ2d@giganews.com> <rdejJ.20399$SW5.15061@fx45.iad> <tIqdncrf0fM86xD8nZ2dnUU7-XednZ2d@giganews.com> <NZejJ.21674$SW5.667@fx45.iad> <hL6dnfx6kfTkHBD8nZ2dnUU7-ROdnZ2d@giganews.com> <PNfjJ.21676$SW5.20549@fx45.iad> <CpidnX-XCpQlEBD8nZ2dnUU7-QWdnZ2d@giganews.com> <lAgjJ.30976$3q9.23015@fx47.iad> <jtadnVpTvr8HABD8nZ2dnUU7-d_NnZ2d@giganews.com> <ahhjJ.16203$b%.15269@fx24.iad> <-JOdnabQjsW9PhD8nZ2dnUU7-W3NnZ2d@giganews.com> <3JhjJ.16204$b%.2566@fx24.iad> <Ztqdnd_gcOaMMhD8nZ2dnUU7-Q-dnZ2d@giganews.com> <FrijJ.21678$SW5.4872@fx45.iad> <7tGdnZfKlojRJxD8nZ2dnUU7-UWdnZ2d@giganews.com> <uPjjJ.11533$xe2.10934@fx16.iad> <f6ednbZ3QKAQVhD8nZ2dnUU7-QHNnZ2d@giganews.com> <ogkjJ.45902$JZ3.6637@fx05.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <ogkjJ.45902$JZ3.6637@fx05.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <s6mdne4JIrg9TBD8nZ2dnUU7-TfNnZ2d@giganews.com>
Lines: 52
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-o0oHTlL4Igf4uOvmn3kV1oqyipOWYSHqLijiikNj4WviZmLeknor3O4GxZlhu9WDtZYmU1zSmve3qkr!abQjfoPzpE/tsLgnGx4vRI8Y1ArfXhQnKEPxUsljzj7+76NZroxO/xDzahkHA/9KKOqsws093c/L!lg==
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 3919
 by: olcott - Fri, 12 Nov 2021 02:29 UTC

On 11/11/2021 8:25 PM, Richard Damon wrote:
> On 11/11/21 9:03 PM, olcott wrote:
>> On 11/11/2021 7:54 PM, Richard Damon wrote:
>>> On 11/11/21 7:50 PM, olcott wrote:
>>>> On 11/11/2021 6:20 PM, Richard Damon wrote:
>>>>>
>>>>> On 11/11/21 7:02 PM, olcott wrote:
>>>>>
>>>>>> I say that P never reaches 1a72.
>>>>>> You say that it does.
>>>>>> I prove that it doesn't
>>>>>> You say that my proof doesn't matter
>>>>>>
>>>>>> That behavior matches the pattern of a liar.
>>>>>>
>>>>>
>>>>> Ok, so your claim now is that that Direct Execution of P(P) never
>>>>> reaches 1A72?
>>>>>
>>>>
>>>> If under every circumstance P never reaches 1a72 then P never halts.
>>>>
>>>
>>> Then why did you say prebviously that P(P) does halt?
>>>
>>
>> If in the computation H(P,P) P never reaches 1a72 for every H that can
>> possibly exist and in the computation P reaches 1a72 then these two
>> computations must be entirely different from each other and able to
>> have inconsistent behavior relative to each other without contradiction.
>
>
> The DEFINITION of the problem that H is set to solve is to predict the
> behavior of the machine that its input is a representation of [Which
> will be the actual computatipn P(P)] which would be the equvalent of
> giving the same input as given to H to a real pure simulator like a UTM
> which simulates until the computation reaches its end (or simulates
> forever if it never will).
>

The computation of H(P,P) is entirely contained within the computation
of P(P) as a part of this larger computation. This by itself
conclusively proves that they are not the same.

--
Copyright 2021 Pete Olcott

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

Pages:12
server_pubkey.txt

rocksolid light 0.9.7
clearnet tor