Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  newsreader  groups  login

Message-ID:  

With all the fancy scientists in the world, why can't they just once build a nuclear balm?


devel / comp.theory / Re: Why do theory of computation problems require pure functions?

SubjectAuthor
* Why do theory of computation problems require pure functions?olcott
+- Why do theory of computation problems require pure functions?dklei...@gmail.com
+* Why do theory of computation problems require pure functions?André G. Isaak
|+* Why do theory of computation problems require pure functions?Jeff Barnett
||`* Why do theory of computation problems require pure functions?André G. Isaak
|| `- Why do theory of computation problems require pure functions?Jeff Barnett
|`* Why do theory of computation problems require pure functions?olcott
| +* Why do theory of computation problems require pure functions?Richard Damon
| |`* Why do theory of computation problems require pure functions?olcott
| | +* Why do theory of computation problems require pure functions?André G. Isaak
| | |+- Why do theory of computation problems require pure functions?olcott
| | |`* Why do theory of computation problems require pure functions?Richard Damon
| | | +* Why do theory of computation problems require pure functions?olcott
| | | |`* Why do theory of computation problems require pure functions?Richard Damon
| | | | `* Why do theory of computation problems require pure functions?olcott
| | | |  `* Why do theory of computation problems require pure functions?Richard Damon
| | | |   `- Why do theory of computation problems require pure functions?olcott
| | | `* Why do theory of computation problems require pure functions?André G. Isaak
| | |  `* Why do theory of computation problems require pure functions?Jeff Barnett
| | |   `* Why do theory of computation problems require pure functions?olcott
| | |    `* Why do theory of computation problems require pure functions?Richard Damon
| | |     `* Why do theory of computation problems require pure functions?olcott
| | |      `* Why do theory of computation problems require pure functions?Richard Damon
| | |       `* Why do theory of computation problems require pure functions?olcott
| | |        +* Why do theory of computation problems require pure functions?Ben Bacarisse
| | |        |`* Why do theory of computation problems require pure functions?olcott
| | |        | +- Why do theory of computation problems require pure functions?Richard Damon
| | |        | `- Why do theory of computation problems require pure functions?Ben Bacarisse
| | |        `- Why do theory of computation problems require pure functions?Richard Damon
| | `* Why do theory of computation problems require pure functions?Richard Damon
| |  `* Why do theory of computation problems require pure functions?olcott
| |   `* Why do theory of computation problems require pure functions?Richard Damon
| |    `* Why do theory of computation problems require pure functions?olcott
| |     `* Why do theory of computation problems require pure functions?Richard Damon
| |      `* Why do theory of computation problems require pure functions?olcott
| |       `* Why do theory of computation problems require pure functions?Richard Damon
| |        `* Why do theory of computation problems require pure functions?olcott
| |         `* Why do theory of computation problems require pure functions?Richard Damon
| |          `* Why do theory of computation problems require pure functions?Ben Bacarisse
| |           `* Why do theory of computation problems require pure functions?olcott
| |            +- Why do theory of computation problems require pure functions?Richard Damon
| |            `- Why do theory of computation problems require pure functions?Ben Bacarisse
| `* Why do theory of computation problems require pure functions?André G. Isaak
|  `* Why do theory of computation problems require pure functions?olcott
|   `* Why do theory of computation problems require pure functions?André G. Isaak
|    `- Why do theory of computation problems require pure functions?olcott
+- Why do theory of computation problems require pure functions?Richard Damon
`* Why do theory of computation problems require pure functions?Andy Walker
 +* Why do theory of computation problems require pure functions?olcott
 |+- Why do theory of computation problems require pure functions?Richard Damon
 |`* Why do theory of computation problems require pure functions?André G. Isaak
 | `* Why do theory of computation problems require pure functions?olcott
 |  +* Why do theory of computation problems require pure functions?Richard Damon
 |  |`* Why do theory of computation problems require pure functions?olcott
 |  | +* Why do theory of computation problems require pure functions?Richard Damon
 |  | |`* Why do theory of computation problems require pure functions?olcott
 |  | | `* Why do theory of computation problems require pure functions?Richard Damon
 |  | |  `* Why do theory of computation problems require pure functions?olcott
 |  | |   `* Why do theory of computation problems require pure functions?Richard Damon
 |  | |    `* Why do theory of computation problems require pure functions?olcott
 |  | |     `* Why do theory of computation problems require pure functions?Richard Damon
 |  | |      `* Why do theory of computation problems require pure functions?olcott
 |  | |       `* Why do theory of computation problems require pure functions?Richard Damon
 |  | |        `* Why do theory of computation problems require pure functions?olcott
 |  | |         `* Why do theory of computation problems require pure functions?Richard Damon
 |  | |          `* Why do theory of computation problems require pure functions?olcott
 |  | |           `* Why do theory of computation problems require pure functions?Richard Damon
 |  | |            `* Why do theory of computation problems require pure functions?olcott
 |  | |             `* Why do theory of computation problems require pure functions?Richard Damon
 |  | |              `* Why do theory of computation problems require pure functions?olcott
 |  | |               `- Why do theory of computation problems require pure functions?Richard Damon
 |  | `- Why do theory of computation problems require pure functions?Ben Bacarisse
 |  +* Why do theory of computation problems require pure functions?André G. Isaak
 |  |`* Why do theory of computation problems require pure functions?olcott
 |  | +* Why do theory of computation problems require pure functions?André G. Isaak
 |  | |`* Why do theory of computation problems require pure functions?olcott
 |  | | `* Why do theory of computation problems require pure functions?Richard Damon
 |  | |  `* Why do theory of computation problems require pure functions?olcott
 |  | |   +* Why do theory of computation problems require pure functions?Richard Damon
 |  | |   |`* Why do theory of computation problems require pure functions?olcott
 |  | |   | `* Why do theory of computation problems require pure functions?Richard Damon
 |  | |   |  `* Why do theory of computation problems require pure functions?olcott
 |  | |   |   +- Why do theory of computation problems require pure functions?Richard Damon
 |  | |   |   `* Why do theory of computation problems require pure functions?André G. Isaak
 |  | |   |    `* Why do theory of computation problems require pure functions?olcott
 |  | |   |     +* Why do theory of computation problems require pure functions?André G. Isaak
 |  | |   |     |`* Why do theory of computation problems require pure functions?olcott
 |  | |   |     | +* Why do theory of computation problems require pure functions?André G. Isaak
 |  | |   |     | |+- Why do theory of computation problems require pure functions?Richard Damon
 |  | |   |     | |+* Why do theory of computation problems require pure functions?olcott
 |  | |   |     | ||+* Why do theory of computation problems require pure functions?Richard Damon
 |  | |   |     | |||`* Why do theory of computation problems require pure functions?olcott
 |  | |   |     | ||| +* Why do theory of computation problems require pure functions?André G. Isaak
 |  | |   |     | ||| |`* Why do theory of computation problems require pure functions?André G. Isaak
 |  | |   |     | ||| | +* Why do theory of computation problems require pure functions?olcott
 |  | |   |     | ||| | |+* Why do theory of computation problems require pure functions?André G. Isaak
 |  | |   |     | ||| | ||`* Why do theory of computation problems require pure functions?[ decidability deciolcott
 |  | |   |     | ||| | || `- Why do theory of computation problems require pure functions?[André G. Isaak
 |  | |   |     | ||| | |`- Why do theory of computation problems require pure functions?Richard Damon
 |  | |   |     | ||| | `* Why do theory of computation problems require pure functions?olcott
 |  | |   |     | ||| |  `* Why do theory of computation problems require pure functions?André G. Isaak
 |  | |   |     | ||| `- Why do theory of computation problems require pure functions?Richard Damon
 |  | |   |     | ||`- Why do theory of computation problems require pure functions?André G. Isaak
 |  | |   |     | |`* Why do theory of computation problems require pure functions?Malcolm McLean
 |  | |   |     | `* Why do theory of computation problems require pure functions?Jeff Barnett
 |  | |   |     `- Why do theory of computation problems require pure functions?Richard Damon
 |  | |   `* Why do theory of computation problems require pure functions?Ben Bacarisse
 |  | `* Why do theory of computation problems require pure functions?Richard Damon
 |  `* Why do theory of computation problems require pure functions?Ben Bacarisse
 `* Why do theory of computation problems require pure functions?Ben Bacarisse

Pages:12345678910
Re: Why do theory of computation problems require pure functions?

<si50lp$960$2@dont-email.me>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: polco...@gmail.com (olcott)
Newsgroups: comp.theory
Subject: Re: Why do theory of computation problems require pure functions?
Date: Sat, 18 Sep 2021 10:29:59 -0500
Organization: A noiseless patient Spider
Lines: 33
Message-ID: <si50lp$960$2@dont-email.me>
References: <a7WdnftR4JAUzNj8nZ2dnUU7-d_NnZ2d@giganews.com>
<si4khe$1nvt$1@gioia.aioe.org>
<mJmdnfaWlv7Kbdj8nZ2dnUU7-YHNnZ2d@giganews.com> <si4v6h$u4l$3@dont-email.me>
<Nc6dnYeBOsuRntv8nZ2dnUU7-QfNnZ2d@giganews.com>
<Awn1J.130330$o45.49337@fx46.iad>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sat, 18 Sep 2021 15:30:01 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="bc1a1bc5547333190b7888a63eca096f";
logging-data="9408"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1+RjwGKHAasoZSOoRiouNs/"
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101
Thunderbird/78.14.0
Cancel-Lock: sha1:a+wWpXBbLiOqwcbuXKeBWDgJbsY=
In-Reply-To: <Awn1J.130330$o45.49337@fx46.iad>
Content-Language: en-US
 by: olcott - Sat, 18 Sep 2021 15:29 UTC

On 9/18/2021 10:24 AM, Richard Damon wrote:
> On 9/18/21 11:17 AM, olcott wrote:
>> On 9/18/2021 10:04 AM, André G. Isaak wrote:
>>> On 2021-09-18 07:57, olcott wrote:
>>>
>>>> I either must stick with C/x86 code or write a RASP machine, the only
>>>> way that my key insights can possible be fully understood is to have
>>>> every single detail as fully operational code such that we can simply
>>>> see what it does and thus not merely imagine what it would do.
>>>
>>> Why do you insist on continuously repeating this rather ridiculous claim?
>>>
>>> When working with Turing Machines one doesn't need to 'merely imagine
>>> what it would do.' One can see *exactly* what it does.
>>>
>>> André
>>>
>>
>> When H is defined as a simulating halt decider then H correctly decides
>> the halt status of ⟨Ĥ⟩ ⟨Ĥ⟩.
>>
>> https://www.liarparadox.org/Peter_Linz_HP(Pages_315-320).pdf
>>
>
> Except that it doesn't, as H says H^(H^) is non-halting when it actually
> Halts.
>

H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to H.qy.

--
Copyright 2021 Pete Olcott "Great spirits have always encountered
violent opposition from mediocre minds." Einstein

Re: Why do theory of computation problems require pure functions?

<PIn1J.39327$2Q_3.774@fx35.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!paganini.bofh.team!news.dns-netz.com!news.freedyn.net!newsfeed.xs4all.nl!newsfeed8.news.xs4all.nl!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer02.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx35.iad.POSTED!not-for-mail
Subject: Re: Why do theory of computation problems require pure functions?
Newsgroups: comp.theory
References: <a7WdnftR4JAUzNj8nZ2dnUU7-d_NnZ2d@giganews.com>
<si4khe$1nvt$1@gioia.aioe.org>
<mJmdnfaWlv7Kbdj8nZ2dnUU7-YHNnZ2d@giganews.com> <si4v6h$u4l$3@dont-email.me>
<Nc6dnYeBOsuRntv8nZ2dnUU7-QfNnZ2d@giganews.com>
<Awn1J.130330$o45.49337@fx46.iad> <si50lp$960$2@dont-email.me>
From: Rich...@Damon-Family.org (Richard Damon)
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:78.0)
Gecko/20100101 Thunderbird/78.14.0
MIME-Version: 1.0
In-Reply-To: <si50lp$960$2@dont-email.me>
Content-Type: text/plain; charset=utf-8
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Lines: 37
Message-ID: <PIn1J.39327$2Q_3.774@fx35.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: Sat, 18 Sep 2021 11:37:19 -0400
X-Received-Bytes: 2555
 by: Richard Damon - Sat, 18 Sep 2021 15:37 UTC

On 9/18/21 11:29 AM, olcott wrote:
> On 9/18/2021 10:24 AM, Richard Damon wrote:
>> On 9/18/21 11:17 AM, olcott wrote:
>>> On 9/18/2021 10:04 AM, André G. Isaak wrote:
>>>> On 2021-09-18 07:57, olcott wrote:
>>>>
>>>>> I either must stick with C/x86 code or write a RASP machine, the only
>>>>> way that my key insights can possible be fully understood is to have
>>>>> every single detail as fully operational code such that we can simply
>>>>> see what it does and thus not merely imagine what it would do.
>>>>
>>>> Why do you insist on continuously repeating this rather ridiculous
>>>> claim?
>>>>
>>>> When working with Turing Machines one doesn't need to 'merely imagine
>>>> what it would do.' One can see *exactly* what it does.
>>>>
>>>> André
>>>>
>>>
>>> When H is defined as a simulating halt decider then H correctly decides
>>> the halt status of ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>
>>> https://www.liarparadox.org/Peter_Linz_HP(Pages_315-320).pdf
>>>
>>
>> Except that it doesn't, as H says H^(H^) is non-halting when it actually
>> Halts.
>>
>
> H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to H.qy.
>

Which says that it is deciding that H^(<H^>) is a non-halting
computation, but if we run H^(<H^>) it ends up at its terminal state
H^.qy which halts. (Since the code for H^ is derived from the code of H,
and the state H^.qn is the corresponding state to H.qn)

Re: Why do theory of computation problems require pure functions?

<goidncl2gvYjmtv8nZ2dnUU7-QnNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!feeder1.feed.usenet.farm!feed.usenet.farm!tr2.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: Sat, 18 Sep 2021 10:37:34 -0500
Subject: Re: Why do theory of computation problems require pure functions?
Newsgroups: comp.theory
References: <a7WdnftR4JAUzNj8nZ2dnUU7-d_NnZ2d@giganews.com> <si3r5q$8ln$1@dont-email.me> <KZSdncvVqtDkctj8nZ2dnUU7-f_NnZ2d@giganews.com> <ZVm1J.3937$7U3.2717@fx24.iad> <j8adnV6gzfcKYdj8nZ2dnUU7-V3NnZ2d@giganews.com> <lmn1J.84222$jl2.75920@fx34.iad> <Nc6dnYaBOsvxntv8nZ2dnUU7-QednZ2d@giganews.com> <Cxn1J.130331$o45.17922@fx46.iad>
From: NoO...@NoWhere.com (olcott)
Date: Sat, 18 Sep 2021 10:37:32 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101 Thunderbird/78.14.0
MIME-Version: 1.0
In-Reply-To: <Cxn1J.130331$o45.17922@fx46.iad>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <goidncl2gvYjmtv8nZ2dnUU7-QnNnZ2d@giganews.com>
Lines: 183
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-VIZixIiL8ls9neGbmbskS8WpltoxRoGAVih4vyVf8J9/srE1AInx0aQSECVLTxCabqsMJMTeqTW2Lo0!IkUoHllSPyuyJlR90FWmsZkiZlAxO2U/rDw2m5J5CWtm9KsXIrsoN174/kt+B4kSPIQEOOcbbVcq!JMw=
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: 9799
 by: olcott - Sat, 18 Sep 2021 15:37 UTC

On 9/18/2021 10:25 AM, Richard Damon wrote:
> On 9/18/21 11:19 AM, olcott wrote:
>> On 9/18/2021 10:13 AM, Richard Damon wrote:
>>> On 9/18/21 10:49 AM, olcott wrote:
>>>> On 9/18/2021 9:43 AM, Richard Damon wrote:
>>>>>
>>>>> On 9/18/21 9:54 AM, olcott wrote:
>>>>>> On 9/17/2021 11:50 PM, André G. Isaak wrote:
>>>>>>> On 2021-09-17 20:40, olcott wrote:
>>>>>>>> Why do theory of computation problems require pure functions?
>>>>>>>
>>>>>>> Because the theory of computation isn't about C or x86. It isn't
>>>>>>> about
>>>>>>> computer programs at all, nor about modern computers. Just because
>>>>>>> 'computation' and 'computer' share the same root doesn't mean they
>>>>>>> deal with the same set of phenomena. Remember that the theory of
>>>>>>> computation developed before there even were digital computers or
>>>>>>> programming languages.
>>>>>>>
>>>>>>> Computational theory is concerned with describing *mathematical*
>>>>>>> functions, and all mathematical functions are pure functions. A
>>>>>>> computation is a method for determining the value of the mathematical
>>>>>>> function f(x) for a given x. A computable function is one for
>>>>>>> which it
>>>>>>> is possible to construct a TM which, given an input string
>>>>>>> representing x, will determine the value of f(x).
>>>>>>>
>>>>>>> You can write computer programs which perform computations, but the
>>>>>>> majority of computer programs don't.
>>>>>>>
>>>>>>> If you really want to learn about the theory of computation, I'd
>>>>>>> suggest that you forget about C or x86 assembly or any sort of
>>>>>>> computer language altogether and focus on Turing Machines.
>>>>>>>
>>>>>>> And don't try to mentally translate anything you read about Turing
>>>>>>> Machines into computer languages. Don't think about loop counters, or
>>>>>>> calls, or machine addresses, because all of these things pertain to
>>>>>>> computers and computer programming rather than computations and they
>>>>>>> will get in the way of you actually understanding either turing
>>>>>>> machines or the theory of computation more generally.
>>>>>>>
>>>>>>> André
>>>>>>>
>>>>>>
>>>>>> I only need to know this for one reason.
>>>>>>
>>>>>> When my halt decider is examining the behavior of its input and the
>>>>>> input calls this halt decider in infinite recursion it cannot keep
>>>>>> track
>>>>>> of the behavior of this input without having a single pseudo static
>>>>>> variable that is directly embedded in its machine code.
>>>>>>
>>>>>> This pseudo static variable stores the ongoing execution trace.
>>>>>> When the
>>>>>> variable is an ordinary local variable it loses all of its data
>>>>>> between
>>>>>> each recursive simulation.
>>>>>>
>>>>>> It still seems to be a pure function of its input in that
>>>>>> (1) The function return values are identical for identical arguments
>>>>>>
>>>>>
>>>>> I think the key issue is that if you want to talk about the plain
>>>>> behavior of C / x86 code, then you need to talk about the ACTUAL
>>>>> behavior of that code, which means that the call to H within the
>>>>> simulated machine needs to be seen as a call to H, and NOT some logical
>>>>> transformation.
>>>>>
>>>>> If you want to do the transformation, your need to actually PROVE that
>>>>> this transform is legitimate under the conditions you want to make it,
>>>>> and that needs a very FORMAL argument based on accepted truths and
>>>>> principles. Your 'argument' based on H not affecting P until after it
>>>>> makes its decision so it can ignore its effect, is one of those
>>>>> arguments that just seems 'obvious' but you haven't actually proved it.
>>>>> You don't seem to uhderstand that nature of how to prove something like
>>>>> this.
>>>>>
>>>>> 'Obvious' things can be wrong, like it seems obvious that the order you
>>>>> add up a series shouldn't affect the result, even if the number of
>>>>> terms
>>>>> in infinite, but there are simple proofs to show that for SOME infinite
>>>>> sums, the order you take the terms can make a difference, dispite it
>>>>> seeming contrary to the nature of addition (infinities break a lot of
>>>>> common sense).
>>>>>
>>>>>
>>>>> A key point about your 'static' variable problem.
>>>>
>>>> There is only a single question here, not the myriad of questions that
>>>> you refer to.
>>>>
>>>> Does my use of a single static variable that holds the ongoing execution
>>>> trace by itself necessarily completely disqualify my system from
>>>> applying to the halting problem or not?
>>>>
>>>> a) Yes
>>>> b) No
>>>
>>> Error of the Complex Question, just like the question of "Have you
>>> stopped lying about your Halt Decider?".
>>>
>>> It isn't the existence of a static variable itself that might disqualify
>>> your system for applying to the halting problem,
>>
>> André disagrees so one of you must be wrong.
>
> Then take his answer and go away as you admit defeat.
>

That is not how categorically exhaustive reasoning works. Categorically
exhaustive reasoning eliminates the possibility of the error of
omission. It results in limited subject domain omniscience.

It only stops when
(1) A solution is found.
(2) No solution exist within omniscience.

>
>>
>>>  but does the existence
>>> of that variable, and the way that your program uses it mean that H is
>>> not an actual Computation. The existence of the variable opens the door
>>> to it being disqualified, but the actual disqualification needs more
>>> information.
>>>
>>> If EVERY call to H(P,I) for a given P and I returns the exact same
>>> answer every time, then H is still a computation.
>>>
>>> The key point here is that When H decides on the call H(P,P) and in that
>>> simulation of P(P) there is a call to H(P,P) then the 'correct' answer
>>> for H needs to take into account that this simulated WILL do exactly the
>>> same thing as the H that is doing the simulation, so if the simulating H
>>> is going to answer Non-Halting, the behavior of the simulated machine
>>> will be based on that simulated H also returning that same answer. Yes,
>>> H is not going to have simulated to that point of the simulated machines
>>> execution, so the simulating H will not be able to see that result, but
>>> that IS the behavior of the machine that it is simulating, and thus
>>> affect what is the 'Right' answer for H to give.
>>>
>>>>
>>>>> If H really WAS a real
>>>>> simulator, then there is no issue with the static variable as only one
>>>>> copy of H is actually execution, all the other copies are just
>>>>> simulation, so the one variable holding the execution trace hold the
>>>>> execution trace of the simulation that it is doing, and there is no
>>>>> issue.
>>>>>
>>>>> The only way that the issue you describe becomes a real issue is if H
>>>>> doesn't ACTUALLY simulate/debug step through copies of itself, but
>>>>> applies some sort of 'transform' to the execution, and you need to have
>>>>> some very good proof that this transform is actually valid, and that
>>>>> the
>>>>> resulting H, which passes data to embedded copies of itself, and thus
>>>>> knows of stuff of its environment beyond what it is supposed to know is
>>>>> actually the equivalent of the decider that doesn't do any of that
>>>>> 'illegal' operations. My guess is that your H is actually NOT the
>>>>> equivalent of such an actual computation and does actually behave
>>>>> differently depending on execution environment, and thus fails to meet
>>>>> the basic requirements.
>>>>>
>>>>> Remember, if the H inside H^ doesn't behave exactly identical to the H
>>>>> that is deciding on that H^, then you aren't working on the right
>>>>> definitions of the system.
>>>>>
>>>>> This seems to be one of your fundamental tripping point, and is one of
>>>>> the issues with doing proofs like this in non-Turing Machine
>>>>> environment
>>>>> (like C/x86 or even RASP) that 'code fragments' can be non-computations
>>>>> and thus not the equivalent of a Turing Machine.
>>>>>
>>>>
>>>>
>>>
>>
>>
>


Click here to read the complete article
Re: Why do theory of computation problems require pure functions?

<goidnch2gvbNldv8nZ2dnUU7-QmdnZ2d@giganews.com>

 copy mid

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

 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: Sat, 18 Sep 2021 10:40:00 -0500
Subject: Re: Why do theory of computation problems require pure functions?
Newsgroups: comp.theory
References: <a7WdnftR4JAUzNj8nZ2dnUU7-d_NnZ2d@giganews.com>
<si4khe$1nvt$1@gioia.aioe.org>
<mJmdnfaWlv7Kbdj8nZ2dnUU7-YHNnZ2d@giganews.com> <si4v6h$u4l$3@dont-email.me>
<Nc6dnYeBOsuRntv8nZ2dnUU7-QfNnZ2d@giganews.com>
<Awn1J.130330$o45.49337@fx46.iad> <si50lp$960$2@dont-email.me>
<PIn1J.39327$2Q_3.774@fx35.iad>
From: NoO...@NoWhere.com (olcott)
Date: Sat, 18 Sep 2021 10:39:59 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101
Thunderbird/78.14.0
MIME-Version: 1.0
In-Reply-To: <PIn1J.39327$2Q_3.774@fx35.iad>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <goidnch2gvbNldv8nZ2dnUU7-QmdnZ2d@giganews.com>
Lines: 48
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-IbxnhgvC4enC+/UoXAXaR9M8k4t9xcCrYriEfO1U9+LWlMjlkBN7fsGocyzfEMObTdWLe3YyqnYj16+!0PTlNlS8rM40C8tAWM0EyVeKpdJ214kxRWpU3adIuysWLXEXC5CF6voZC/c8JisGUqcwb3m+JmP3!slY=
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: 3212
 by: olcott - Sat, 18 Sep 2021 15:39 UTC

On 9/18/2021 10:37 AM, Richard Damon wrote:
> On 9/18/21 11:29 AM, olcott wrote:
>> On 9/18/2021 10:24 AM, Richard Damon wrote:
>>> On 9/18/21 11:17 AM, olcott wrote:
>>>> On 9/18/2021 10:04 AM, André G. Isaak wrote:
>>>>> On 2021-09-18 07:57, olcott wrote:
>>>>>
>>>>>> I either must stick with C/x86 code or write a RASP machine, the only
>>>>>> way that my key insights can possible be fully understood is to have
>>>>>> every single detail as fully operational code such that we can simply
>>>>>> see what it does and thus not merely imagine what it would do.
>>>>>
>>>>> Why do you insist on continuously repeating this rather ridiculous
>>>>> claim?
>>>>>
>>>>> When working with Turing Machines one doesn't need to 'merely imagine
>>>>> what it would do.' One can see *exactly* what it does.
>>>>>
>>>>> André
>>>>>
>>>>
>>>> When H is defined as a simulating halt decider then H correctly decides
>>>> the halt status of ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>
>>>> https://www.liarparadox.org/Peter_Linz_HP(Pages_315-320).pdf
>>>>
>>>
>>> Except that it doesn't, as H says H^(H^) is non-halting when it actually
>>> Halts.
>>>
>>
>> H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to H.qy.
>>
>
> Which says that it is deciding that H^(<H^>) is a non-halting
> computation, but if we run H^(<H^>) it ends up at its terminal state
> H^.qy which halts. (Since the code for H^ is derived from the code of H,
> and the state H^.qn is the corresponding state to H.qn)
>

So does my use of a static local variable by itself make my code not
apply to the halting problem or not?

--
Copyright 2021 Pete Olcott

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

Re: Why do theory of computation problems require pure functions?

<ZNn1J.36461$ol1.1275@fx42.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!newsfeed.xs4all.nl!newsfeed7.news.xs4all.nl!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer02.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx42.iad.POSTED!not-for-mail
Subject: Re: Why do theory of computation problems require pure functions?
Newsgroups: comp.theory
References: <a7WdnftR4JAUzNj8nZ2dnUU7-d_NnZ2d@giganews.com>
<si3r5q$8ln$1@dont-email.me> <KZSdncvVqtDkctj8nZ2dnUU7-f_NnZ2d@giganews.com>
<ZVm1J.3937$7U3.2717@fx24.iad>
<j8adnV6gzfcKYdj8nZ2dnUU7-V3NnZ2d@giganews.com> <si4v1h$u4l$2@dont-email.me>
<rvn1J.130329$o45.114860@fx46.iad> <si50iu$960$1@dont-email.me>
From: Rich...@Damon-Family.org (Richard Damon)
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:78.0)
Gecko/20100101 Thunderbird/78.14.0
MIME-Version: 1.0
In-Reply-To: <si50iu$960$1@dont-email.me>
Content-Type: text/plain; charset=utf-8
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Lines: 63
Message-ID: <ZNn1J.36461$ol1.1275@fx42.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: Sat, 18 Sep 2021 11:42:48 -0400
X-Received-Bytes: 3863
 by: Richard Damon - Sat, 18 Sep 2021 15:42 UTC

On 9/18/21 11:28 AM, olcott wrote:
> On 9/18/2021 10:23 AM, Richard Damon wrote:
>> On 9/18/21 11:02 AM, André G. Isaak wrote:
>>> On 2021-09-18 08:49, olcott wrote:
>>>> On 9/18/2021 9:43 AM, Richard Damon wrote:
>>>
>>>> Does my use of a single static variable that holds the ongoing
>>>> execution trace by itself necessarily completely disqualify my system
>>>> from applying to the halting problem or not?
>>>>
>>>> a) Yes
>>>> b) No
>>>
>>> (a) Yes.
>>>
>>> André
>>>
>>
>> That is incorrect, as it is quite possible to have a program that IS a
>> computation that still has a static variable, it a categorical No can be
>> disproven.
>>
>> If his halt decider does ACTUALLY SIMULATE the provided program (and not
>> execute it under a debugger) then in the execution context of the
>> decider never actually has any recursion occurring, so only one copy of
>> the decider ever sees that value of that variable at any given time.
>>
>> Yes, it appears that the way his current design works, the static
>> variable provides an information back channel between different 'levels'
>> of the decider running and that affects the behavior of the different
>> 'levels' so it is not a Computation, but the mere presence of a static
>> variable isn't enough.
>>
>> For example, the common trick of memoizing a function to save previous
>> calculated results to make it run faster does not in of itself
>> disqualify a function from being a true computation.
>>
>
> Only the master UTM / halt decider makes the halt status decision.
> The slave UTM halt deciders merely update the execution trace data.
>

But do the slaves deciders act any differently than the master as far as
answer?

Would the first slave return the same non-halting answer to its caller
that the master does? If not, it isn't a Computation.

Admittedly, this becomes a bit philosophical since you system has broken
on of the keys requirements of H^ using a COPY of H (since one
computation can't actually call code not within it), so the slave
machine will never be able to reach that state.

The key is that if we replace the 'Master UTM/halt decider' with an
actual UTM that doesn't abort, but keep the rest of the system useing
the original code, that 'slave' decider needs to act just like the
master would have, and THAT determines the correct answer.

Of course we run into the problem that because you have broken the
actual Computational Equivalence by having H^ call the exact same copy
of H as is deciding it which can't actually be done by Turing Machines
in the configuration required, you can't actually implement this in your
C code.

Re: Why do theory of computation problems require pure functions?

<gPn1J.36462$ol1.15837@fx42.iad>

 copy mid

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

 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!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx42.iad.POSTED!not-for-mail
Subject: Re: Why do theory of computation problems require pure functions?
Newsgroups: comp.theory
References: <a7WdnftR4JAUzNj8nZ2dnUU7-d_NnZ2d@giganews.com>
<si3r5q$8ln$1@dont-email.me> <KZSdncvVqtDkctj8nZ2dnUU7-f_NnZ2d@giganews.com>
<ZVm1J.3937$7U3.2717@fx24.iad>
<j8adnV6gzfcKYdj8nZ2dnUU7-V3NnZ2d@giganews.com>
<lmn1J.84222$jl2.75920@fx34.iad>
<Nc6dnYaBOsvxntv8nZ2dnUU7-QednZ2d@giganews.com>
<Cxn1J.130331$o45.17922@fx46.iad>
<goidncl2gvYjmtv8nZ2dnUU7-QnNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:78.0)
Gecko/20100101 Thunderbird/78.14.0
MIME-Version: 1.0
In-Reply-To: <goidncl2gvYjmtv8nZ2dnUU7-QnNnZ2d@giganews.com>
Content-Type: text/plain; charset=utf-8
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Lines: 208
Message-ID: <gPn1J.36462$ol1.15837@fx42.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: Sat, 18 Sep 2021 11:44:11 -0400
X-Received-Bytes: 9886
X-Original-Bytes: 9753
 by: Richard Damon - Sat, 18 Sep 2021 15:44 UTC

On 9/18/21 11:37 AM, olcott wrote:
> On 9/18/2021 10:25 AM, Richard Damon wrote:
>> On 9/18/21 11:19 AM, olcott wrote:
>>> On 9/18/2021 10:13 AM, Richard Damon wrote:
>>>> On 9/18/21 10:49 AM, olcott wrote:
>>>>> On 9/18/2021 9:43 AM, Richard Damon wrote:
>>>>>>
>>>>>> On 9/18/21 9:54 AM, olcott wrote:
>>>>>>> On 9/17/2021 11:50 PM, André G. Isaak wrote:
>>>>>>>> On 2021-09-17 20:40, olcott wrote:
>>>>>>>>> Why do theory of computation problems require pure functions?
>>>>>>>>
>>>>>>>> Because the theory of computation isn't about C or x86. It isn't
>>>>>>>> about
>>>>>>>> computer programs at all, nor about modern computers. Just because
>>>>>>>> 'computation' and 'computer' share the same root doesn't mean they
>>>>>>>> deal with the same set of phenomena. Remember that the theory of
>>>>>>>> computation developed before there even were digital computers or
>>>>>>>> programming languages.
>>>>>>>>
>>>>>>>> Computational theory is concerned with describing *mathematical*
>>>>>>>> functions, and all mathematical functions are pure functions. A
>>>>>>>> computation is a method for determining the value of the
>>>>>>>> mathematical
>>>>>>>> function f(x) for a given x. A computable function is one for
>>>>>>>> which it
>>>>>>>> is possible to construct a TM which, given an input string
>>>>>>>> representing x, will determine the value of f(x).
>>>>>>>>
>>>>>>>> You can write computer programs which perform computations, but the
>>>>>>>> majority of computer programs don't.
>>>>>>>>
>>>>>>>> If you really want to learn about the theory of computation, I'd
>>>>>>>> suggest that you forget about C or x86 assembly or any sort of
>>>>>>>> computer language altogether and focus on Turing Machines.
>>>>>>>>
>>>>>>>> And don't try to mentally translate anything you read about Turing
>>>>>>>> Machines into computer languages. Don't think about loop
>>>>>>>> counters, or
>>>>>>>> calls, or machine addresses, because all of these things pertain to
>>>>>>>> computers and computer programming rather than computations and
>>>>>>>> they
>>>>>>>> will get in the way of you actually understanding either turing
>>>>>>>> machines or the theory of computation more generally.
>>>>>>>>
>>>>>>>> André
>>>>>>>>
>>>>>>>
>>>>>>> I only need to know this for one reason.
>>>>>>>
>>>>>>> When my halt decider is examining the behavior of its input and the
>>>>>>> input calls this halt decider in infinite recursion it cannot keep
>>>>>>> track
>>>>>>> of the behavior of this input without having a single pseudo static
>>>>>>> variable that is directly embedded in its machine code.
>>>>>>>
>>>>>>> This pseudo static variable stores the ongoing execution trace.
>>>>>>> When the
>>>>>>> variable is an ordinary local variable it loses all of its data
>>>>>>> between
>>>>>>> each recursive simulation.
>>>>>>>
>>>>>>> It still seems to be a pure function of its input in that
>>>>>>> (1) The function return values are identical for identical arguments
>>>>>>>
>>>>>>
>>>>>> I think the key issue is that if you want to talk about the plain
>>>>>> behavior of C / x86 code, then you need to talk about the ACTUAL
>>>>>> behavior of that code, which means that the call to H within the
>>>>>> simulated machine needs to be seen as a call to H, and NOT some
>>>>>> logical
>>>>>> transformation.
>>>>>>
>>>>>> If you want to do the transformation, your need to actually PROVE
>>>>>> that
>>>>>> this transform is legitimate under the conditions you want to make
>>>>>> it,
>>>>>> and that needs a very FORMAL argument based on accepted truths and
>>>>>> principles. Your 'argument' based on H not affecting P until after it
>>>>>> makes its decision so it can ignore its effect, is one of those
>>>>>> arguments that just seems 'obvious' but you haven't actually
>>>>>> proved it.
>>>>>> You don't seem to uhderstand that nature of how to prove something
>>>>>> like
>>>>>> this.
>>>>>>
>>>>>> 'Obvious' things can be wrong, like it seems obvious that the
>>>>>> order you
>>>>>> add up a series shouldn't affect the result, even if the number of
>>>>>> terms
>>>>>> in infinite, but there are simple proofs to show that for SOME
>>>>>> infinite
>>>>>> sums, the order you take the terms can make a difference, dispite it
>>>>>> seeming contrary to the nature of addition (infinities break a lot of
>>>>>> common sense).
>>>>>>
>>>>>>
>>>>>> A key point about your 'static' variable problem.
>>>>>
>>>>> There is only a single question here, not the myriad of questions that
>>>>> you refer to.
>>>>>
>>>>> Does my use of a single static variable that holds the ongoing
>>>>> execution
>>>>> trace by itself necessarily completely disqualify my system from
>>>>> applying to the halting problem or not?
>>>>>
>>>>> a) Yes
>>>>> b) No
>>>>
>>>> Error of the Complex Question, just like the question of "Have you
>>>> stopped lying about your Halt Decider?".
>>>>
>>>> It isn't the existence of a static variable itself that might
>>>> disqualify
>>>> your system for applying to the halting problem,
>>>
>>> André disagrees so one of you must be wrong.
>>
>> Then take his answer and go away as you admit defeat.
>>
>
> That is not how categorically exhaustive reasoning works. Categorically
> exhaustive reasoning eliminates the possibility of the error of
> omission. It results in limited subject domain omniscience.
>
> It only stops when
> (1) A solution is found.
> (2) No solution exist within omniscience.

But your question, as I explained, was not categorically exhaustive.

Have you stopped lying about your Halt Decider?

>
>>
>>>
>>>>   but does the existence
>>>> of that variable, and the way that your program uses it mean that H is
>>>> not an actual Computation. The existence of the variable opens the door
>>>> to it being disqualified, but the actual disqualification needs more
>>>> information.
>>>>
>>>> If EVERY call to H(P,I) for a given P and I returns the exact same
>>>> answer every time, then H is still a computation.
>>>>
>>>> The key point here is that When H decides on the call H(P,P) and in
>>>> that
>>>> simulation of P(P) there is a call to H(P,P) then the 'correct' answer
>>>> for H needs to take into account that this simulated WILL do exactly
>>>> the
>>>> same thing as the H that is doing the simulation, so if the
>>>> simulating H
>>>> is going to answer Non-Halting, the behavior of the simulated machine
>>>> will be based on that simulated H also returning that same answer. Yes,
>>>> H is not going to have simulated to that point of the simulated
>>>> machines
>>>> execution, so the simulating H will not be able to see that result, but
>>>> that IS the behavior of the machine that it is simulating, and thus
>>>> affect what is the 'Right' answer for H to give.
>>>>
>>>>>
>>>>>> If H really WAS a real
>>>>>> simulator, then there is no issue with the static variable as only
>>>>>> one
>>>>>> copy of H is actually execution, all the other copies are just
>>>>>> simulation, so the one variable holding the execution trace hold the
>>>>>> execution trace of the simulation that it is doing, and there is no
>>>>>> issue.
>>>>>>
>>>>>> The only way that the issue you describe becomes a real issue is if H
>>>>>> doesn't ACTUALLY simulate/debug step through copies of itself, but
>>>>>> applies some sort of 'transform' to the execution, and you need to
>>>>>> have
>>>>>> some very good proof that this transform is actually valid, and that
>>>>>> the
>>>>>> resulting H, which passes data to embedded copies of itself, and thus
>>>>>> knows of stuff of its environment beyond what it is supposed to
>>>>>> know is
>>>>>> actually the equivalent of the decider that doesn't do any of that
>>>>>> 'illegal' operations. My guess is that your H is actually NOT the
>>>>>> equivalent of such an actual computation and does actually behave
>>>>>> differently depending on execution environment, and thus fails to
>>>>>> meet
>>>>>> the basic requirements.
>>>>>>
>>>>>> Remember, if the H inside H^ doesn't behave exactly identical to
>>>>>> the H
>>>>>> that is deciding on that H^, then you aren't working on the right
>>>>>> definitions of the system.
>>>>>>
>>>>>> This seems to be one of your fundamental tripping point, and is
>>>>>> one of
>>>>>> the issues with doing proofs like this in non-Turing Machine
>>>>>> environment
>>>>>> (like C/x86 or even RASP) that 'code fragments' can be
>>>>>> non-computations
>>>>>> and thus not the equivalent of a Turing Machine.
>>>>>>
>>>>>
>>>>>
>>>>
>>>
>>>
>>
>
>


Click here to read the complete article
Re: Why do theory of computation problems require pure functions?

<Ao6dnXPvWs6Lltv8nZ2dnUU7-cnNnZ2d@giganews.com>

 copy mid

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

 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: Sat, 18 Sep 2021 10:51:50 -0500
Subject: Re: Why do theory of computation problems require pure functions?
Newsgroups: comp.theory
References: <a7WdnftR4JAUzNj8nZ2dnUU7-d_NnZ2d@giganews.com>
<si3r5q$8ln$1@dont-email.me> <KZSdncvVqtDkctj8nZ2dnUU7-f_NnZ2d@giganews.com>
<ZVm1J.3937$7U3.2717@fx24.iad>
<j8adnV6gzfcKYdj8nZ2dnUU7-V3NnZ2d@giganews.com> <si4v1h$u4l$2@dont-email.me>
<rvn1J.130329$o45.114860@fx46.iad> <si50iu$960$1@dont-email.me>
<ZNn1J.36461$ol1.1275@fx42.iad>
From: NoO...@NoWhere.com (olcott)
Date: Sat, 18 Sep 2021 10:51:49 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101
Thunderbird/78.14.0
MIME-Version: 1.0
In-Reply-To: <ZNn1J.36461$ol1.1275@fx42.iad>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <Ao6dnXPvWs6Lltv8nZ2dnUU7-cnNnZ2d@giganews.com>
Lines: 90
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-dR27eH2yDwJYCY2lQQrulYNID9Nm6vSw/l/03lK6FCbs6qFSnrCM7zimzwR1VIa8Lqu/52oljB0ShOv!l6J/kTJsnffGzsQ8mszrzM5GCRcgI7f7UPHEmEjof1Rcf9eIU/mSYsvgB1XKz8MS+o1QLlTayNYR!Aoc=
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: 5069
 by: olcott - Sat, 18 Sep 2021 15:51 UTC

On 9/18/2021 10:42 AM, Richard Damon wrote:
> On 9/18/21 11:28 AM, olcott wrote:
>> On 9/18/2021 10:23 AM, Richard Damon wrote:
>>> On 9/18/21 11:02 AM, André G. Isaak wrote:
>>>> On 2021-09-18 08:49, olcott wrote:
>>>>> On 9/18/2021 9:43 AM, Richard Damon wrote:
>>>>
>>>>> Does my use of a single static variable that holds the ongoing
>>>>> execution trace by itself necessarily completely disqualify my system
>>>>> from applying to the halting problem or not?
>>>>>
>>>>> a) Yes
>>>>> b) No
>>>>
>>>> (a) Yes.
>>>>
>>>> André
>>>>
>>>
>>> That is incorrect, as it is quite possible to have a program that IS a
>>> computation that still has a static variable, it a categorical No can be
>>> disproven.
>>>
>>> If his halt decider does ACTUALLY SIMULATE the provided program (and not
>>> execute it under a debugger) then in the execution context of the
>>> decider never actually has any recursion occurring, so only one copy of
>>> the decider ever sees that value of that variable at any given time.
>>>
>>> Yes, it appears that the way his current design works, the static
>>> variable provides an information back channel between different 'levels'
>>> of the decider running and that affects the behavior of the different
>>> 'levels' so it is not a Computation, but the mere presence of a static
>>> variable isn't enough.
>>>
>>> For example, the common trick of memoizing a function to save previous
>>> calculated results to make it run faster does not in of itself
>>> disqualify a function from being a true computation.
>>>
>>
>> Only the master UTM / halt decider makes the halt status decision.
>> The slave UTM halt deciders merely update the execution trace data.
>>
>
> But do the slaves deciders act any differently than the master as far as
> answer?
>

They know that they are not allowed to derive an answer.
They are only allowed to update the execution trace.

> Would the first slave return the same non-halting answer to its caller
> that the master does? If not, it isn't a Computation.
>
> Admittedly, this becomes a bit philosophical since you system has broken
> on of the keys requirements of H^ using a COPY of H (since one
> computation can't actually call code not within it), so the slave
> machine will never be able to reach that state.
>

In my H1/H computation H1 is a copy of H.
This is equivalent to H applied to ⟨Ĥ⟩ ⟨Ĥ⟩

> The key is that if we replace the 'Master UTM/halt decider' with an
> actual UTM that doesn't abort, but keep the rest of the system useing
> the original code, that 'slave' decider needs to act just like the
> master would have, and THAT determines the correct answer.
>

The slave knows that it is not allowed to make a halt status decision
because a slave making such a decision would not be a pure function of
its input.

> Of course we run into the problem that because you have broken the
> actual Computational Equivalence by having H^ call the exact same copy
> of H as is deciding it which can't actually be done by Turing Machines
> in the configuration required, you can't actually implement this in your
> C code.
>

I can yet it makes my solution much more complex. After six months where
no one seems to have much of a slight glimmer of actual understanding
making my system more complex could only make understanding it
impossibly difficult.

--
Copyright 2021 Pete Olcott

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

Re: Why do theory of computation problems require pure functions?

<_Wn1J.168986$T_8.81874@fx48.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!paganini.bofh.team!news.dns-netz.com!news.freedyn.net!newsfeed.xs4all.nl!newsfeed8.news.xs4all.nl!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer01.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx48.iad.POSTED!not-for-mail
Subject: Re: Why do theory of computation problems require pure functions?
Newsgroups: comp.theory
References: <a7WdnftR4JAUzNj8nZ2dnUU7-d_NnZ2d@giganews.com>
<si4khe$1nvt$1@gioia.aioe.org>
<mJmdnfaWlv7Kbdj8nZ2dnUU7-YHNnZ2d@giganews.com> <si4v6h$u4l$3@dont-email.me>
<Nc6dnYeBOsuRntv8nZ2dnUU7-QfNnZ2d@giganews.com>
<Awn1J.130330$o45.49337@fx46.iad> <si50lp$960$2@dont-email.me>
<PIn1J.39327$2Q_3.774@fx35.iad>
<goidnch2gvbNldv8nZ2dnUU7-QmdnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:78.0)
Gecko/20100101 Thunderbird/78.14.0
MIME-Version: 1.0
In-Reply-To: <goidnch2gvbNldv8nZ2dnUU7-QmdnZ2d@giganews.com>
Content-Type: text/plain; charset=utf-8
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Lines: 67
Message-ID: <_Wn1J.168986$T_8.81874@fx48.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: Sat, 18 Sep 2021 11:52:26 -0400
X-Received-Bytes: 3775
 by: Richard Damon - Sat, 18 Sep 2021 15:52 UTC

On 9/18/21 11:39 AM, olcott wrote:
> On 9/18/2021 10:37 AM, Richard Damon wrote:
>> On 9/18/21 11:29 AM, olcott wrote:
>>> On 9/18/2021 10:24 AM, Richard Damon wrote:
>>>> On 9/18/21 11:17 AM, olcott wrote:
>>>>> On 9/18/2021 10:04 AM, André G. Isaak wrote:
>>>>>> On 2021-09-18 07:57, olcott wrote:
>>>>>>
>>>>>>> I either must stick with C/x86 code or write a RASP machine, the
>>>>>>> only
>>>>>>> way that my key insights can possible be fully understood is to have
>>>>>>> every single detail as fully operational code such that we can
>>>>>>> simply
>>>>>>> see what it does and thus not merely imagine what it would do.
>>>>>>
>>>>>> Why do you insist on continuously repeating this rather ridiculous
>>>>>> claim?
>>>>>>
>>>>>> When working with Turing Machines one doesn't need to 'merely imagine
>>>>>> what it would do.' One can see *exactly* what it does.
>>>>>>
>>>>>> André
>>>>>>
>>>>>
>>>>> When H is defined as a simulating halt decider then H correctly
>>>>> decides
>>>>> the halt status of ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>
>>>>> https://www.liarparadox.org/Peter_Linz_HP(Pages_315-320).pdf
>>>>>
>>>>
>>>> Except that it doesn't, as H says H^(H^) is non-halting when it
>>>> actually
>>>> Halts.
>>>>
>>>
>>> H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to H.qy.
>>>
>>
>> Which says that it is deciding that H^(<H^>) is a non-halting
>> computation, but if we run H^(<H^>) it ends up at its terminal state
>> H^.qy which halts. (Since the code for H^ is derived from the code of H,
>> and the state H^.qn is the corresponding state to H.qn)
>>
>
> So does my use of a static local variable by itself make my code not
> apply to the halting problem or not?
>

No, but that doesn't mean that the presence of the static local variable
is unconditionally allowed.

You need to PROVE that your program is a Computation.

Lack of things like static local variables make that proof much easier.
as if all information inside the program can only be derived from the
official input, then there is no source of 'illegal' information.

Presence of things like static local variables don't by themselves
invalidate you ability to be a Computation, but do mean you really do
need to show that it is one.

So, as of now, the proposition that your code is eligible to be a
decider is unproven, and can not just be 'assumed'

If we ever see a case where two copies of H given the same input act
differently, then this statement is proved in the negative.

Re: Why do theory of computation problems require pure functions?

<w2o1J.78872$g81.36562@fx33.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer01.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx33.iad.POSTED!not-for-mail
Subject: Re: Why do theory of computation problems require pure functions?
Newsgroups: comp.theory
References: <a7WdnftR4JAUzNj8nZ2dnUU7-d_NnZ2d@giganews.com>
<si3r5q$8ln$1@dont-email.me> <KZSdncvVqtDkctj8nZ2dnUU7-f_NnZ2d@giganews.com>
<ZVm1J.3937$7U3.2717@fx24.iad>
<j8adnV6gzfcKYdj8nZ2dnUU7-V3NnZ2d@giganews.com> <si4v1h$u4l$2@dont-email.me>
<rvn1J.130329$o45.114860@fx46.iad> <si50iu$960$1@dont-email.me>
<ZNn1J.36461$ol1.1275@fx42.iad>
<Ao6dnXPvWs6Lltv8nZ2dnUU7-cnNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:78.0)
Gecko/20100101 Thunderbird/78.14.0
MIME-Version: 1.0
In-Reply-To: <Ao6dnXPvWs6Lltv8nZ2dnUU7-cnNnZ2d@giganews.com>
Content-Type: text/plain; charset=utf-8
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Lines: 114
Message-ID: <w2o1J.78872$g81.36562@fx33.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: Sat, 18 Sep 2021 12:00:27 -0400
X-Received-Bytes: 5786
 by: Richard Damon - Sat, 18 Sep 2021 16:00 UTC

On 9/18/21 11:51 AM, olcott wrote:
> On 9/18/2021 10:42 AM, Richard Damon wrote:
>> On 9/18/21 11:28 AM, olcott wrote:
>>> On 9/18/2021 10:23 AM, Richard Damon wrote:
>>>> On 9/18/21 11:02 AM, André G. Isaak wrote:
>>>>> On 2021-09-18 08:49, olcott wrote:
>>>>>> On 9/18/2021 9:43 AM, Richard Damon wrote:
>>>>>
>>>>>> Does my use of a single static variable that holds the ongoing
>>>>>> execution trace by itself necessarily completely disqualify my system
>>>>>> from applying to the halting problem or not?
>>>>>>
>>>>>> a) Yes
>>>>>> b) No
>>>>>
>>>>> (a) Yes.
>>>>>
>>>>> André
>>>>>
>>>>
>>>> That is incorrect, as it is quite possible to have a program that IS a
>>>> computation that still has a static variable, it a categorical No
>>>> can be
>>>> disproven.
>>>>
>>>> If his halt decider does ACTUALLY SIMULATE the provided program (and
>>>> not
>>>> execute it under a debugger) then in the execution context of the
>>>> decider never actually has any recursion occurring, so only one copy of
>>>> the decider ever sees that value of that variable at any given time.
>>>>
>>>> Yes, it appears that the way his current design works, the static
>>>> variable provides an information back channel between different
>>>> 'levels'
>>>> of the decider running and that affects the behavior of the different
>>>> 'levels' so it is not a Computation, but the mere presence of a static
>>>> variable isn't enough.
>>>>
>>>> For example, the common trick of memoizing a function to save previous
>>>> calculated results to make it run faster does not in of itself
>>>> disqualify a function from being a true computation.
>>>>
>>>
>>> Only the master UTM / halt decider makes the halt status decision.
>>> The slave UTM halt deciders merely update the execution trace data.
>>>
>>
>> But do the slaves deciders act any differently than the master as far as
>> answer?
>>
>
> They know that they are not allowed to derive an answer.
> They are only allowed to update the execution trace.

But it MUST derive the same answer for the same input as the master.

That seems to be the flaw in your logic.

>
>> Would the first slave return the same non-halting answer to its caller
>> that the master does? If not, it isn't a Computation.
>>
>> Admittedly, this becomes a bit philosophical since you system has broken
>> on of the keys requirements of H^ using a COPY of H (since one
>> computation can't actually call code not within it), so the slave
>> machine will never be able to reach that state.
>>
>
> In my H1/H computation H1 is a copy of H.
> This is equivalent to H applied to ⟨Ĥ⟩ ⟨Ĥ⟩

But H1 and H are NOT the same computation since H(P,I) and H1(P,I)
return different values. DEFINITION.

If anything, this just proves that H isn't a computation, and that your
static local variable did change the behavior of the H inside the P that
is being decided.

>
>> The key is that if we replace the 'Master UTM/halt decider' with an
>> actual UTM that doesn't abort, but keep the rest of the system useing
>> the original code, that 'slave' decider needs to act just like the
>> master would have, and THAT determines the correct answer.
>>
>
> The slave knows that it is not allowed to make a halt status decision
> because a slave making such a decision would not be a pure function of
> its input.

But it MUST make the same decision from the trace that it IS allowed to
see. If it changes its behavior because it sees it is a slave, it has
broken the requirements.

>
>> Of course we run into the problem that because you have broken the
>> actual Computational Equivalence by having H^ call the exact same copy
>> of H as is deciding it which can't actually be done by Turing Machines
>> in the configuration required, you can't actually implement this in your
>> C code.
>>
>
> I can yet it makes my solution much more complex. After six months where
> no one seems to have much of a slight glimmer of actual understanding
> making my system more complex could only make understanding it
> impossibly difficult.
>

It isn't the complexity. You have broken the rules but won't admit it,
and try to hide it inside complexity.

Your 'slaves' don't act just like the master, as in the master makes
supposedly correct predictions based on the slaves acting differently
then it does. This makes your code not a computation, and thus not
eligable to be a decider.

Re: Why do theory of computation problems require pure functions?

<qYmdneD7KY-Pktv8nZ2dnUU7-YHNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!aioe.org!feeder1.feed.usenet.farm!feed.usenet.farm!tr1.eu1.usenetexpress.com!feeder.usenetexpress.com!tr2.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: Sat, 18 Sep 2021 11:08:50 -0500
Subject: Re: Why do theory of computation problems require pure functions?
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <a7WdnftR4JAUzNj8nZ2dnUU7-d_NnZ2d@giganews.com> <si3r5q$8ln$1@dont-email.me> <KZSdncvVqtDkctj8nZ2dnUU7-f_NnZ2d@giganews.com> <ZVm1J.3937$7U3.2717@fx24.iad> <j8adnV6gzfcKYdj8nZ2dnUU7-V3NnZ2d@giganews.com> <lmn1J.84222$jl2.75920@fx34.iad> <Nc6dnYaBOsvxntv8nZ2dnUU7-QednZ2d@giganews.com> <Cxn1J.130331$o45.17922@fx46.iad> <goidncl2gvYjmtv8nZ2dnUU7-QnNnZ2d@giganews.com> <gPn1J.36462$ol1.15837@fx42.iad>
From: NoO...@NoWhere.com (olcott)
Date: Sat, 18 Sep 2021 11:08:47 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101 Thunderbird/78.14.0
MIME-Version: 1.0
In-Reply-To: <gPn1J.36462$ol1.15837@fx42.iad>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <qYmdneD7KY-Pktv8nZ2dnUU7-YHNnZ2d@giganews.com>
Lines: 243
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-kLprHRIz9TJZ67i6/D+sL/YGec00M+8wXy7wVFo4nXQkWyj27yrDz3KxfXmnNJcze/Os6ck4wVXnciF!yCQAycT902LgBS5XYheRJ/LSWWZeSCYpyb3d4LMeioycliiW1+yiYavob32g17WxsMkxuyRrMiUG!ES8=
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: 11812
 by: olcott - Sat, 18 Sep 2021 16:08 UTC

On 9/18/2021 10:44 AM, Richard Damon wrote:
> On 9/18/21 11:37 AM, olcott wrote:
>> On 9/18/2021 10:25 AM, Richard Damon wrote:
>>> On 9/18/21 11:19 AM, olcott wrote:
>>>> On 9/18/2021 10:13 AM, Richard Damon wrote:
>>>>> On 9/18/21 10:49 AM, olcott wrote:
>>>>>> On 9/18/2021 9:43 AM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 9/18/21 9:54 AM, olcott wrote:
>>>>>>>> On 9/17/2021 11:50 PM, André G. Isaak wrote:
>>>>>>>>> On 2021-09-17 20:40, olcott wrote:
>>>>>>>>>> Why do theory of computation problems require pure functions?
>>>>>>>>>
>>>>>>>>> Because the theory of computation isn't about C or x86. It isn't
>>>>>>>>> about
>>>>>>>>> computer programs at all, nor about modern computers. Just because
>>>>>>>>> 'computation' and 'computer' share the same root doesn't mean they
>>>>>>>>> deal with the same set of phenomena. Remember that the theory of
>>>>>>>>> computation developed before there even were digital computers or
>>>>>>>>> programming languages.
>>>>>>>>>
>>>>>>>>> Computational theory is concerned with describing *mathematical*
>>>>>>>>> functions, and all mathematical functions are pure functions. A
>>>>>>>>> computation is a method for determining the value of the
>>>>>>>>> mathematical
>>>>>>>>> function f(x) for a given x. A computable function is one for
>>>>>>>>> which it
>>>>>>>>> is possible to construct a TM which, given an input string
>>>>>>>>> representing x, will determine the value of f(x).
>>>>>>>>>
>>>>>>>>> You can write computer programs which perform computations, but the
>>>>>>>>> majority of computer programs don't.
>>>>>>>>>
>>>>>>>>> If you really want to learn about the theory of computation, I'd
>>>>>>>>> suggest that you forget about C or x86 assembly or any sort of
>>>>>>>>> computer language altogether and focus on Turing Machines.
>>>>>>>>>
>>>>>>>>> And don't try to mentally translate anything you read about Turing
>>>>>>>>> Machines into computer languages. Don't think about loop
>>>>>>>>> counters, or
>>>>>>>>> calls, or machine addresses, because all of these things pertain to
>>>>>>>>> computers and computer programming rather than computations and
>>>>>>>>> they
>>>>>>>>> will get in the way of you actually understanding either turing
>>>>>>>>> machines or the theory of computation more generally.
>>>>>>>>>
>>>>>>>>> André
>>>>>>>>>
>>>>>>>>
>>>>>>>> I only need to know this for one reason.
>>>>>>>>
>>>>>>>> When my halt decider is examining the behavior of its input and the
>>>>>>>> input calls this halt decider in infinite recursion it cannot keep
>>>>>>>> track
>>>>>>>> of the behavior of this input without having a single pseudo static
>>>>>>>> variable that is directly embedded in its machine code.
>>>>>>>>
>>>>>>>> This pseudo static variable stores the ongoing execution trace.
>>>>>>>> When the
>>>>>>>> variable is an ordinary local variable it loses all of its data
>>>>>>>> between
>>>>>>>> each recursive simulation.
>>>>>>>>
>>>>>>>> It still seems to be a pure function of its input in that
>>>>>>>> (1) The function return values are identical for identical arguments
>>>>>>>>
>>>>>>>
>>>>>>> I think the key issue is that if you want to talk about the plain
>>>>>>> behavior of C / x86 code, then you need to talk about the ACTUAL
>>>>>>> behavior of that code, which means that the call to H within the
>>>>>>> simulated machine needs to be seen as a call to H, and NOT some
>>>>>>> logical
>>>>>>> transformation.
>>>>>>>
>>>>>>> If you want to do the transformation, your need to actually PROVE
>>>>>>> that
>>>>>>> this transform is legitimate under the conditions you want to make
>>>>>>> it,
>>>>>>> and that needs a very FORMAL argument based on accepted truths and
>>>>>>> principles. Your 'argument' based on H not affecting P until after it
>>>>>>> makes its decision so it can ignore its effect, is one of those
>>>>>>> arguments that just seems 'obvious' but you haven't actually
>>>>>>> proved it.
>>>>>>> You don't seem to uhderstand that nature of how to prove something
>>>>>>> like
>>>>>>> this.
>>>>>>>
>>>>>>> 'Obvious' things can be wrong, like it seems obvious that the
>>>>>>> order you
>>>>>>> add up a series shouldn't affect the result, even if the number of
>>>>>>> terms
>>>>>>> in infinite, but there are simple proofs to show that for SOME
>>>>>>> infinite
>>>>>>> sums, the order you take the terms can make a difference, dispite it
>>>>>>> seeming contrary to the nature of addition (infinities break a lot of
>>>>>>> common sense).
>>>>>>>
>>>>>>>
>>>>>>> A key point about your 'static' variable problem.
>>>>>>
>>>>>> There is only a single question here, not the myriad of questions that
>>>>>> you refer to.
>>>>>>
>>>>>> Does my use of a single static variable that holds the ongoing
>>>>>> execution
>>>>>> trace by itself necessarily completely disqualify my system from
>>>>>> applying to the halting problem or not?
>>>>>>
>>>>>> a) Yes
>>>>>> b) No
>>>>>
>>>>> Error of the Complex Question, just like the question of "Have you
>>>>> stopped lying about your Halt Decider?".
>>>>>
>>>>> It isn't the existence of a static variable itself that might
>>>>> disqualify
>>>>> your system for applying to the halting problem,
>>>>
>>>> André disagrees so one of you must be wrong.
>>>
>>> Then take his answer and go away as you admit defeat.
>>>
>>
>> That is not how categorically exhaustive reasoning works. Categorically
>> exhaustive reasoning eliminates the possibility of the error of
>> omission. It results in limited subject domain omniscience.
>>
>> It only stops when
>> (1) A solution is found.
>> (2) No solution exist within omniscience.
>
> But your question, as I explained, was not categorically exhaustive.
>

Polar (yes/no) questions only have {yes, no} answers.
{yes,no} completely exhausts the entire category of answers to polar
(yes/no) questions.

> Have you stopped lying about your Halt Decider?

To the best of my knowledge I have only actually lied once in the last
ten years. I lied to a close friend about a very hurtful truth to
protect them from this very hurtful truth.

I do the best that I can to always tell the truth for two reasons:
(1) I have a very deep passion for mathematically formalizing the notion
of analytical truth and this is the sole reason why I pursue:
(a) The Halting Problem
(b) Gödel's 1931 incompleteness theorem
(c) The Tarski Undefinability theorem
(d) The Liar Paradox

(2) I honestly believe that people intentionally spreading dangerous
lies such as 2020 election fraud and covid-19 disinformation may be
eternally incinerated:


Click here to read the complete article
Re: Why do theory of computation problems require pure functions?

<si5307$q3f$1@dont-email.me>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: agis...@gm.invalid (André G. Isaak)
Newsgroups: comp.theory
Subject: Re: Why do theory of computation problems require pure functions?
Date: Sat, 18 Sep 2021 10:09:42 -0600
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 51
Message-ID: <si5307$q3f$1@dont-email.me>
References: <a7WdnftR4JAUzNj8nZ2dnUU7-d_NnZ2d@giganews.com>
<si3r5q$8ln$1@dont-email.me> <KZSdncvVqtDkctj8nZ2dnUU7-f_NnZ2d@giganews.com>
<si4v0f$u4l$1@dont-email.me> <XMWdnTGSKtQenNv8nZ2dnUU7-LPNnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sat, 18 Sep 2021 16:09:44 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="b2780b02a2648bf8f0dad6d21eb6aca0";
logging-data="26735"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1/3HlZRxwrqNT9fKr0Nq0rK"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:68.0)
Gecko/20100101 Thunderbird/68.12.1
Cancel-Lock: sha1:WL2cAj0VuT9qFS9+oYkS9z/qa6c=
In-Reply-To: <XMWdnTGSKtQenNv8nZ2dnUU7-LPNnZ2d@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Sat, 18 Sep 2021 16:09 UTC

On 2021-09-18 09:10, olcott wrote:
> On 9/18/2021 10:01 AM, André G. Isaak wrote:
>> On 2021-09-18 07:54, olcott wrote:

>>> It still seems to be a pure function of its input in that
>>> (1) The function return values are identical for identical arguments
>>
>> Except that it doesn't.
>>
>
> For the purpose of this dialogue it is stipulated that it does, thus
> even if it does not it is to be construed that it does.

So your proof is going to rest on 'stipulating' that your program
behaves in a way which it does not? I hate to break it to you, but
that's not how proofs work. Otherwise, I could offer the following proof.

(1) I stipulate that P = NP
(2) Therefore P = NP

How much money do do you think I should demand from the global ecommerce
industry to keep this result secret from the world?

> If we assume that all cats are dogs then the question:
> Do cats bark is correctly anwered as: yes.

Umm. No. It is not.

For starters, not all dogs bark to begin with. So unless you also
'stipulate' that all dogs bark your conclusion doesn't follow.

Secondly, and more importantly, your 'stipulation' isn't going to have
any effect whatsoever on the behavior of my cat.

When you stipulate counterfactuals, you leave open a huge range of
possible interpretations: Are you envisioning an alternate universe in
which cats behave differently? Or an alternate universe in which the
word 'cat' refers to a different set of entities? Or an alternate
universe in which there are no cats? Or, were it actually the case that
all dogs bark, are you envisioning an alternate universe in which this
is not the case? Or some other possibility altogether?

Crucially, though, your 'stipulation' remains a counterfactual. It tells
us nothing whatsoever about the *actual* universe, nor can it be used in
a proof regarding the actual universe.

André

--
To email remove 'invalid' & replace 'gm' with well known Google mail
service.

Re: Why do theory of computation problems require pure functions?

<si531f$q3f$2@dont-email.me>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: agis...@gm.invalid (André G. Isaak)
Newsgroups: comp.theory
Subject: Re: Why do theory of computation problems require pure functions?
Date: Sat, 18 Sep 2021 10:10:23 -0600
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 28
Message-ID: <si531f$q3f$2@dont-email.me>
References: <a7WdnftR4JAUzNj8nZ2dnUU7-d_NnZ2d@giganews.com>
<si4khe$1nvt$1@gioia.aioe.org>
<mJmdnfaWlv7Kbdj8nZ2dnUU7-YHNnZ2d@giganews.com> <si4v6h$u4l$3@dont-email.me>
<Nc6dnYeBOsuRntv8nZ2dnUU7-QfNnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sat, 18 Sep 2021 16:10:23 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="b2780b02a2648bf8f0dad6d21eb6aca0";
logging-data="26735"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX182n8jCXw6IuvgtO3PamZma"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:68.0)
Gecko/20100101 Thunderbird/68.12.1
Cancel-Lock: sha1:v7aQkXslJsSfPzNkYGMtP50nHNk=
In-Reply-To: <Nc6dnYeBOsuRntv8nZ2dnUU7-QfNnZ2d@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Sat, 18 Sep 2021 16:10 UTC

On 2021-09-18 09:17, olcott wrote:
> On 9/18/2021 10:04 AM, André G. Isaak wrote:
>> On 2021-09-18 07:57, olcott wrote:
>>
>>> I either must stick with C/x86 code or write a RASP machine, the only
>>> way that my key insights can possible be fully understood is to have
>>> every single detail as fully operational code such that we can simply
>>> see what it does and thus not merely imagine what it would do.
>>
>> Why do you insist on continuously repeating this rather ridiculous claim?
>>
>> When working with Turing Machines one doesn't need to 'merely imagine
>> what it would do.' One can see *exactly* what it does.
>>
>> André
>>
>
> When H is defined as a simulating halt decider then H correctly decides
> the halt status of ⟨Ĥ⟩ ⟨Ĥ⟩.

And this statement relates to my post how exactly?

André

--
To email remove 'invalid' & replace 'gm' with well known Google mail
service.

Re: Why do theory of computation problems require pure functions?

<2f6dnYwdyrUFjdv8nZ2dnUU7-dHNnZ2d@giganews.com>

 copy mid

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

 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: Sat, 18 Sep 2021 11:15:20 -0500
Subject: Re: Why do theory of computation problems require pure functions?
Newsgroups: comp.theory
References: <a7WdnftR4JAUzNj8nZ2dnUU7-d_NnZ2d@giganews.com>
<si4khe$1nvt$1@gioia.aioe.org>
<mJmdnfaWlv7Kbdj8nZ2dnUU7-YHNnZ2d@giganews.com> <si4v6h$u4l$3@dont-email.me>
<Nc6dnYeBOsuRntv8nZ2dnUU7-QfNnZ2d@giganews.com>
<Awn1J.130330$o45.49337@fx46.iad> <si50lp$960$2@dont-email.me>
<PIn1J.39327$2Q_3.774@fx35.iad>
<goidnch2gvbNldv8nZ2dnUU7-QmdnZ2d@giganews.com>
<_Wn1J.168986$T_8.81874@fx48.iad>
From: NoO...@NoWhere.com (olcott)
Date: Sat, 18 Sep 2021 11:15:18 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101
Thunderbird/78.14.0
MIME-Version: 1.0
In-Reply-To: <_Wn1J.168986$T_8.81874@fx48.iad>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <2f6dnYwdyrUFjdv8nZ2dnUU7-dHNnZ2d@giganews.com>
Lines: 86
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-C0zVIOUlCLYVvN8t0A7vH58QMc8UkfLFrObQbj3xwLLSExw4/3lwB16LNOl1t4AwHmHvb4rN4VNPBY1!ladvNUkBxu5+j/K06THNLhxg437Fwwgp87L3a/Fjfo5ZnH4+3VkGrbx8T5mRzn40yOv/yR3UH+Rf!ktg=
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: 4665
 by: olcott - Sat, 18 Sep 2021 16:15 UTC

On 9/18/2021 10:52 AM, Richard Damon wrote:
> On 9/18/21 11:39 AM, olcott wrote:
>> On 9/18/2021 10:37 AM, Richard Damon wrote:
>>> On 9/18/21 11:29 AM, olcott wrote:
>>>> On 9/18/2021 10:24 AM, Richard Damon wrote:
>>>>> On 9/18/21 11:17 AM, olcott wrote:
>>>>>> On 9/18/2021 10:04 AM, André G. Isaak wrote:
>>>>>>> On 2021-09-18 07:57, olcott wrote:
>>>>>>>
>>>>>>>> I either must stick with C/x86 code or write a RASP machine, the
>>>>>>>> only
>>>>>>>> way that my key insights can possible be fully understood is to have
>>>>>>>> every single detail as fully operational code such that we can
>>>>>>>> simply
>>>>>>>> see what it does and thus not merely imagine what it would do.
>>>>>>>
>>>>>>> Why do you insist on continuously repeating this rather ridiculous
>>>>>>> claim?
>>>>>>>
>>>>>>> When working with Turing Machines one doesn't need to 'merely imagine
>>>>>>> what it would do.' One can see *exactly* what it does.
>>>>>>>
>>>>>>> André
>>>>>>>
>>>>>>
>>>>>> When H is defined as a simulating halt decider then H correctly
>>>>>> decides
>>>>>> the halt status of ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>>
>>>>>> https://www.liarparadox.org/Peter_Linz_HP(Pages_315-320).pdf
>>>>>>
>>>>>
>>>>> Except that it doesn't, as H says H^(H^) is non-halting when it
>>>>> actually
>>>>> Halts.
>>>>>
>>>>
>>>> H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to H.qy.
>>>>
>>>
>>> Which says that it is deciding that H^(<H^>) is a non-halting
>>> computation, but if we run H^(<H^>) it ends up at its terminal state
>>> H^.qy which halts. (Since the code for H^ is derived from the code of H,
>>> and the state H^.qn is the corresponding state to H.qn)
>>>
>>
>> So does my use of a static local variable by itself make my code not
>> apply to the halting problem or not?
>>
>
> No, but that doesn't mean that the presence of the static local variable
> is unconditionally allowed.
>
> You need to PROVE that your program is a Computation.
>
> Lack of things like static local variables make that proof much easier.
> as if all information inside the program can only be derived from the
> official input, then there is no source of 'illegal' information.
>

The halt status decision is entirely based on the execution trace
derived from the input machine address pair.

> Presence of things like static local variables don't by themselves
> invalidate you ability to be a Computation, but do mean you really do
> need to show that it is one.
>

That is great. What are the requirements of a computation?

given an input of the function domain it can return the corresponding
output. https://en.wikipedia.org/wiki/Computable_function

> So, as of now, the proposition that your code is eligible to be a
> decider is unproven, and can not just be 'assumed'
>
> If we ever see a case where two copies of H given the same input act
> differently, then this statement is proved in the negative.
>

--
Copyright 2021 Pete Olcott

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

Re: Why do theory of computation problems require pure functions?

<4to1J.96063$Kv2.76439@fx47.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!feeder1.feed.usenet.farm!feed.usenet.farm!nntp.speedium.network!feeder01!81.171.65.16.MISMATCH!peer03.ams4!peer.am4.highwinds-media.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx47.iad.POSTED!not-for-mail
Subject: Re: Why do theory of computation problems require pure functions?
Newsgroups: comp.theory
References: <a7WdnftR4JAUzNj8nZ2dnUU7-d_NnZ2d@giganews.com>
<si4khe$1nvt$1@gioia.aioe.org>
<mJmdnfaWlv7Kbdj8nZ2dnUU7-YHNnZ2d@giganews.com> <si4v6h$u4l$3@dont-email.me>
<Nc6dnYeBOsuRntv8nZ2dnUU7-QfNnZ2d@giganews.com>
<Awn1J.130330$o45.49337@fx46.iad> <si50lp$960$2@dont-email.me>
<PIn1J.39327$2Q_3.774@fx35.iad>
<goidnch2gvbNldv8nZ2dnUU7-QmdnZ2d@giganews.com>
<_Wn1J.168986$T_8.81874@fx48.iad>
<2f6dnYwdyrUFjdv8nZ2dnUU7-dHNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:78.0)
Gecko/20100101 Thunderbird/78.14.0
MIME-Version: 1.0
In-Reply-To: <2f6dnYwdyrUFjdv8nZ2dnUU7-dHNnZ2d@giganews.com>
Content-Type: text/plain; charset=utf-8
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Lines: 107
Message-ID: <4to1J.96063$Kv2.76439@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: Sat, 18 Sep 2021 12:28:47 -0400
X-Received-Bytes: 5287
 by: Richard Damon - Sat, 18 Sep 2021 16:28 UTC

On 9/18/21 12:15 PM, olcott wrote:
> On 9/18/2021 10:52 AM, Richard Damon wrote:
>> On 9/18/21 11:39 AM, olcott wrote:
>>> On 9/18/2021 10:37 AM, Richard Damon wrote:
>>>> On 9/18/21 11:29 AM, olcott wrote:
>>>>> On 9/18/2021 10:24 AM, Richard Damon wrote:
>>>>>> On 9/18/21 11:17 AM, olcott wrote:
>>>>>>> On 9/18/2021 10:04 AM, André G. Isaak wrote:
>>>>>>>> On 2021-09-18 07:57, olcott wrote:
>>>>>>>>
>>>>>>>>> I either must stick with C/x86 code or write a RASP machine, the
>>>>>>>>> only
>>>>>>>>> way that my key insights can possible be fully understood is to
>>>>>>>>> have
>>>>>>>>> every single detail as fully operational code such that we can
>>>>>>>>> simply
>>>>>>>>> see what it does and thus not merely imagine what it would do.
>>>>>>>>
>>>>>>>> Why do you insist on continuously repeating this rather ridiculous
>>>>>>>> claim?
>>>>>>>>
>>>>>>>> When working with Turing Machines one doesn't need to 'merely
>>>>>>>> imagine
>>>>>>>> what it would do.' One can see *exactly* what it does.
>>>>>>>>
>>>>>>>> André
>>>>>>>>
>>>>>>>
>>>>>>> When H is defined as a simulating halt decider then H correctly
>>>>>>> decides
>>>>>>> the halt status of ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>>>
>>>>>>> https://www.liarparadox.org/Peter_Linz_HP(Pages_315-320).pdf
>>>>>>>
>>>>>>
>>>>>> Except that it doesn't, as H says H^(H^) is non-halting when it
>>>>>> actually
>>>>>> Halts.
>>>>>>
>>>>>
>>>>> H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to H.qy.
>>>>>
>>>>
>>>> Which says that it is deciding that H^(<H^>) is a non-halting
>>>> computation, but if we run H^(<H^>) it ends up at its terminal state
>>>> H^.qy which halts. (Since the code for H^ is derived from the code
>>>> of H,
>>>> and the state H^.qn is the corresponding state to H.qn)
>>>>
>>>
>>> So does my use of a static local variable by itself make my code not
>>> apply to the halting problem or not?
>>>
>>
>> No, but that doesn't mean that the presence of the static local variable
>> is unconditionally allowed.
>>
>> You need to PROVE that your program is a Computation.
>>
>> Lack of things like static local variables make that proof much easier.
>> as if all information inside the program can only be derived from the
>> official input, then there is no source of 'illegal' information.
>>
>
> The halt status decision is entirely based on the execution trace
> derived from the input machine address pair.

Right, but that ALSO applies to the simulated copies of H, which need to
give the exact same answer given the exact same input.

This means that since the 'master' H(P,P) returns non-halting, that must
be consistent with the copy of H inside P ALSO return the answer of
non-halting when given that exact same input.

The 'assumption' that it will not return is a violation of that.

Either H is using unsound logic, or H is not a computation because the
'slave' H doesn't behave the same way.

>
>> Presence of things like static local variables don't by themselves
>> invalidate you ability to be a Computation, but do mean you really do
>> need to show that it is one.
>>
>
> That is great. What are the requirements of a computation?
>
> given an input of the function domain it can return the corresponding
> output. https://en.wikipedia.org/wiki/Computable_function

It is a bit more that a function with a specific value for a specific
input, as it also needs to be the results of an 'algorithm', a step by
step listing of instructions to get to the result.

If all of the inputs to the algorithm are part of the formal input to
the function, then you get a computation.

>
>> So, as of now, the proposition that your code is eligible to be a
>> decider is unproven, and can not just be 'assumed'
>>
>> If we ever see a case where two copies of H given the same input act
>> differently, then this statement is proved in the negative.
>>
>
>

Re: Why do theory of computation problems require pure functions?

<si5458$2de$1@dont-email.me>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: agis...@gm.invalid (André G. Isaak)
Newsgroups: comp.theory
Subject: Re: Why do theory of computation problems require pure functions?
Date: Sat, 18 Sep 2021 10:29:27 -0600
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 34
Message-ID: <si5458$2de$1@dont-email.me>
References: <a7WdnftR4JAUzNj8nZ2dnUU7-d_NnZ2d@giganews.com>
<si3r5q$8ln$1@dont-email.me> <KZSdncvVqtDkctj8nZ2dnUU7-f_NnZ2d@giganews.com>
<ZVm1J.3937$7U3.2717@fx24.iad>
<j8adnV6gzfcKYdj8nZ2dnUU7-V3NnZ2d@giganews.com> <si4v1h$u4l$2@dont-email.me>
<rvn1J.130329$o45.114860@fx46.iad>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sat, 18 Sep 2021 16:29:29 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="b2780b02a2648bf8f0dad6d21eb6aca0";
logging-data="2478"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX19pFcjpehVvRE3yuU0CrDbf"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:68.0)
Gecko/20100101 Thunderbird/68.12.1
Cancel-Lock: sha1:hay7Ax+gq45GhF4YS9ilT9nl57I=
In-Reply-To: <rvn1J.130329$o45.114860@fx46.iad>
Content-Language: en-US
 by: André G. Isaak - Sat, 18 Sep 2021 16:29 UTC

On 2021-09-18 09:23, Richard Damon wrote:
> On 9/18/21 11:02 AM, André G. Isaak wrote:
>> On 2021-09-18 08:49, olcott wrote:
>>> On 9/18/2021 9:43 AM, Richard Damon wrote:
>>
>>> Does my use of a single static variable that holds the ongoing
>>> execution trace by itself necessarily completely disqualify my system
>>> from applying to the halting problem or not?
>>>
>>> a) Yes
>>> b) No
>>
>> (a) Yes.
>>
>> André
>>
>
> That is incorrect, as it is quite possible to have a program that IS a
> computation that still has a static variable, it a categorical No can be
> disproven.

Perhaps a better way of putting it would be that if a function
absolutely *requires* a static variable to achieve the desired result,
then it does not represent a computation.

I went with (a) because Olcott is incapable of processing answers which
include anything resembling 'details' or 'nuance'. All answers must be
completely black and white.

André

--
To email remove 'invalid' & replace 'gm' with well known Google mail
service.

Re: Why do theory of computation problems require pure functions?

<Swo1J.31123$nR3.24966@fx38.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!news.swapon.de!news.uzoreto.com!peer03.ams4!peer.am4.highwinds-media.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx38.iad.POSTED!not-for-mail
Subject: Re: Why do theory of computation problems require pure functions?
Newsgroups: comp.theory
References: <a7WdnftR4JAUzNj8nZ2dnUU7-d_NnZ2d@giganews.com>
<si3r5q$8ln$1@dont-email.me> <KZSdncvVqtDkctj8nZ2dnUU7-f_NnZ2d@giganews.com>
<ZVm1J.3937$7U3.2717@fx24.iad>
<j8adnV6gzfcKYdj8nZ2dnUU7-V3NnZ2d@giganews.com>
<lmn1J.84222$jl2.75920@fx34.iad>
<Nc6dnYaBOsvxntv8nZ2dnUU7-QednZ2d@giganews.com>
<Cxn1J.130331$o45.17922@fx46.iad>
<goidncl2gvYjmtv8nZ2dnUU7-QnNnZ2d@giganews.com>
<gPn1J.36462$ol1.15837@fx42.iad>
<qYmdneD7KY-Pktv8nZ2dnUU7-YHNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:78.0)
Gecko/20100101 Thunderbird/78.14.0
MIME-Version: 1.0
In-Reply-To: <qYmdneD7KY-Pktv8nZ2dnUU7-YHNnZ2d@giganews.com>
Content-Type: text/plain; charset=utf-8
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Lines: 274
Message-ID: <Swo1J.31123$nR3.24966@fx38.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: Sat, 18 Sep 2021 12:32:50 -0400
X-Received-Bytes: 12421
 by: Richard Damon - Sat, 18 Sep 2021 16:32 UTC

On 9/18/21 12:08 PM, olcott wrote:
> On 9/18/2021 10:44 AM, Richard Damon wrote:
>> On 9/18/21 11:37 AM, olcott wrote:
>>> On 9/18/2021 10:25 AM, Richard Damon wrote:
>>>> On 9/18/21 11:19 AM, olcott wrote:
>>>>> On 9/18/2021 10:13 AM, Richard Damon wrote:
>>>>>> On 9/18/21 10:49 AM, olcott wrote:
>>>>>>> On 9/18/2021 9:43 AM, Richard Damon wrote:
>>>>>>>>
>>>>>>>> On 9/18/21 9:54 AM, olcott wrote:
>>>>>>>>> On 9/17/2021 11:50 PM, André G. Isaak wrote:
>>>>>>>>>> On 2021-09-17 20:40, olcott wrote:
>>>>>>>>>>> Why do theory of computation problems require pure functions?
>>>>>>>>>>
>>>>>>>>>> Because the theory of computation isn't about C or x86. It isn't
>>>>>>>>>> about
>>>>>>>>>> computer programs at all, nor about modern computers. Just
>>>>>>>>>> because
>>>>>>>>>> 'computation' and 'computer' share the same root doesn't mean
>>>>>>>>>> they
>>>>>>>>>> deal with the same set of phenomena. Remember that the theory of
>>>>>>>>>> computation developed before there even were digital computers or
>>>>>>>>>> programming languages.
>>>>>>>>>>
>>>>>>>>>> Computational theory is concerned with describing *mathematical*
>>>>>>>>>> functions, and all mathematical functions are pure functions. A
>>>>>>>>>> computation is a method for determining the value of the
>>>>>>>>>> mathematical
>>>>>>>>>> function f(x) for a given x. A computable function is one for
>>>>>>>>>> which it
>>>>>>>>>> is possible to construct a TM which, given an input string
>>>>>>>>>> representing x, will determine the value of f(x).
>>>>>>>>>>
>>>>>>>>>> You can write computer programs which perform computations,
>>>>>>>>>> but the
>>>>>>>>>> majority of computer programs don't.
>>>>>>>>>>
>>>>>>>>>> If you really want to learn about the theory of computation, I'd
>>>>>>>>>> suggest that you forget about C or x86 assembly or any sort of
>>>>>>>>>> computer language altogether and focus on Turing Machines.
>>>>>>>>>>
>>>>>>>>>> And don't try to mentally translate anything you read about
>>>>>>>>>> Turing
>>>>>>>>>> Machines into computer languages. Don't think about loop
>>>>>>>>>> counters, or
>>>>>>>>>> calls, or machine addresses, because all of these things
>>>>>>>>>> pertain to
>>>>>>>>>> computers and computer programming rather than computations and
>>>>>>>>>> they
>>>>>>>>>> will get in the way of you actually understanding either turing
>>>>>>>>>> machines or the theory of computation more generally.
>>>>>>>>>>
>>>>>>>>>> André
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> I only need to know this for one reason.
>>>>>>>>>
>>>>>>>>> When my halt decider is examining the behavior of its input and
>>>>>>>>> the
>>>>>>>>> input calls this halt decider in infinite recursion it cannot keep
>>>>>>>>> track
>>>>>>>>> of the behavior of this input without having a single pseudo
>>>>>>>>> static
>>>>>>>>> variable that is directly embedded in its machine code.
>>>>>>>>>
>>>>>>>>> This pseudo static variable stores the ongoing execution trace.
>>>>>>>>> When the
>>>>>>>>> variable is an ordinary local variable it loses all of its data
>>>>>>>>> between
>>>>>>>>> each recursive simulation.
>>>>>>>>>
>>>>>>>>> It still seems to be a pure function of its input in that
>>>>>>>>> (1) The function return values are identical for identical
>>>>>>>>> arguments
>>>>>>>>>
>>>>>>>>
>>>>>>>> I think the key issue is that if you want to talk about the plain
>>>>>>>> behavior of C / x86 code, then you need to talk about the ACTUAL
>>>>>>>> behavior of that code, which means that the call to H within the
>>>>>>>> simulated machine needs to be seen as a call to H, and NOT some
>>>>>>>> logical
>>>>>>>> transformation.
>>>>>>>>
>>>>>>>> If you want to do the transformation, your need to actually PROVE
>>>>>>>> that
>>>>>>>> this transform is legitimate under the conditions you want to make
>>>>>>>> it,
>>>>>>>> and that needs a very FORMAL argument based on accepted truths and
>>>>>>>> principles. Your 'argument' based on H not affecting P until
>>>>>>>> after it
>>>>>>>> makes its decision so it can ignore its effect, is one of those
>>>>>>>> arguments that just seems 'obvious' but you haven't actually
>>>>>>>> proved it.
>>>>>>>> You don't seem to uhderstand that nature of how to prove something
>>>>>>>> like
>>>>>>>> this.
>>>>>>>>
>>>>>>>> 'Obvious' things can be wrong, like it seems obvious that the
>>>>>>>> order you
>>>>>>>> add up a series shouldn't affect the result, even if the number of
>>>>>>>> terms
>>>>>>>> in infinite, but there are simple proofs to show that for SOME
>>>>>>>> infinite
>>>>>>>> sums, the order you take the terms can make a difference,
>>>>>>>> dispite it
>>>>>>>> seeming contrary to the nature of addition (infinities break a
>>>>>>>> lot of
>>>>>>>> common sense).
>>>>>>>>
>>>>>>>>
>>>>>>>> A key point about your 'static' variable problem.
>>>>>>>
>>>>>>> There is only a single question here, not the myriad of questions
>>>>>>> that
>>>>>>> you refer to.
>>>>>>>
>>>>>>> Does my use of a single static variable that holds the ongoing
>>>>>>> execution
>>>>>>> trace by itself necessarily completely disqualify my system from
>>>>>>> applying to the halting problem or not?
>>>>>>>
>>>>>>> a) Yes
>>>>>>> b) No
>>>>>>
>>>>>> Error of the Complex Question, just like the question of "Have you
>>>>>> stopped lying about your Halt Decider?".
>>>>>>
>>>>>> It isn't the existence of a static variable itself that might
>>>>>> disqualify
>>>>>> your system for applying to the halting problem,
>>>>>
>>>>> André disagrees so one of you must be wrong.
>>>>
>>>> Then take his answer and go away as you admit defeat.
>>>>
>>>
>>> That is not how categorically exhaustive reasoning works. Categorically
>>> exhaustive reasoning eliminates the possibility of the error of
>>> omission. It results in limited subject domain omniscience.
>>>
>>> It only stops when
>>> (1) A solution is found.
>>> (2) No solution exist within omniscience.
>>
>> But your question, as I explained, was not categorically exhaustive.
>>
>
> Polar (yes/no) questions only have {yes, no} answers.
> {yes,no} completely exhausts the entire category of answers to polar
> (yes/no) questions.


Click here to read the complete article
Re: Why do theory of computation problems require pure functions?

<-oidnU49zceuiNv8nZ2dnUU7-YHNnZ2d@giganews.com>

 copy mid

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

 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!feeder1.feed.usenet.farm!feed.usenet.farm!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: Sat, 18 Sep 2021 11:34:59 -0500
Subject: Re: Why do theory of computation problems require pure functions?
Newsgroups: comp.theory
References: <a7WdnftR4JAUzNj8nZ2dnUU7-d_NnZ2d@giganews.com> <si3r5q$8ln$1@dont-email.me> <KZSdncvVqtDkctj8nZ2dnUU7-f_NnZ2d@giganews.com> <ZVm1J.3937$7U3.2717@fx24.iad> <j8adnV6gzfcKYdj8nZ2dnUU7-V3NnZ2d@giganews.com> <si4v1h$u4l$2@dont-email.me> <rvn1J.130329$o45.114860@fx46.iad> <si50iu$960$1@dont-email.me> <ZNn1J.36461$ol1.1275@fx42.iad> <Ao6dnXPvWs6Lltv8nZ2dnUU7-cnNnZ2d@giganews.com> <w2o1J.78872$g81.36562@fx33.iad>
From: NoO...@NoWhere.com (olcott)
Date: Sat, 18 Sep 2021 11:34:53 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101 Thunderbird/78.14.0
MIME-Version: 1.0
In-Reply-To: <w2o1J.78872$g81.36562@fx33.iad>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <-oidnU49zceuiNv8nZ2dnUU7-YHNnZ2d@giganews.com>
Lines: 154
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-GHt4BRNeDb1HqWAjZQsmiw77r+7i+Bd5rHSfznCcs9ls+2z3DHuv0Kn5hVlcnpVWAO9dVrkLjsQDfa3!WBE4Z0DdHjd3qZvjKy2LjOIDpSyQgSDE0h5ZBCAOAClW3s+ehjdOiizPr3LtFY5m7wCDEnZSkM7T!Dnc=
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: 7726
 by: olcott - Sat, 18 Sep 2021 16:34 UTC

On 9/18/2021 11:00 AM, Richard Damon wrote:
> On 9/18/21 11:51 AM, olcott wrote:
>> On 9/18/2021 10:42 AM, Richard Damon wrote:
>>> On 9/18/21 11:28 AM, olcott wrote:
>>>> On 9/18/2021 10:23 AM, Richard Damon wrote:
>>>>> On 9/18/21 11:02 AM, André G. Isaak wrote:
>>>>>> On 2021-09-18 08:49, olcott wrote:
>>>>>>> On 9/18/2021 9:43 AM, Richard Damon wrote:
>>>>>>
>>>>>>> Does my use of a single static variable that holds the ongoing
>>>>>>> execution trace by itself necessarily completely disqualify my system
>>>>>>> from applying to the halting problem or not?
>>>>>>>
>>>>>>> a) Yes
>>>>>>> b) No
>>>>>>
>>>>>> (a) Yes.
>>>>>>
>>>>>> André
>>>>>>
>>>>>
>>>>> That is incorrect, as it is quite possible to have a program that IS a
>>>>> computation that still has a static variable, it a categorical No
>>>>> can be
>>>>> disproven.
>>>>>
>>>>> If his halt decider does ACTUALLY SIMULATE the provided program (and
>>>>> not
>>>>> execute it under a debugger) then in the execution context of the
>>>>> decider never actually has any recursion occurring, so only one copy of
>>>>> the decider ever sees that value of that variable at any given time.
>>>>>
>>>>> Yes, it appears that the way his current design works, the static
>>>>> variable provides an information back channel between different
>>>>> 'levels'
>>>>> of the decider running and that affects the behavior of the different
>>>>> 'levels' so it is not a Computation, but the mere presence of a static
>>>>> variable isn't enough.
>>>>>
>>>>> For example, the common trick of memoizing a function to save previous
>>>>> calculated results to make it run faster does not in of itself
>>>>> disqualify a function from being a true computation.
>>>>>
>>>>
>>>> Only the master UTM / halt decider makes the halt status decision.
>>>> The slave UTM halt deciders merely update the execution trace data.
>>>>
>>>
>>> But do the slaves deciders act any differently than the master as far as
>>> answer?
>>>
>>
>> They know that they are not allowed to derive an answer.
>> They are only allowed to update the execution trace.
>
> But it MUST derive the same answer for the same input as the master.
>

The slave that sees that the infinite execution pattern was matched
reports the same halt status decision as the master. Until my redesign
it was the only instance that reported any result because it was the one
that saw this result first.

> That seems to be the flaw in your logic.
>
>>
>>> Would the first slave return the same non-halting answer to its caller
>>> that the master does? If not, it isn't a Computation.
>>>
>>> Admittedly, this becomes a bit philosophical since you system has broken
>>> on of the keys requirements of H^ using a COPY of H (since one
>>> computation can't actually call code not within it), so the slave
>>> machine will never be able to reach that state.
>>>
>>
>> In my H1/H computation H1 is a copy of H.
>> This is equivalent to H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
>
> But H1 and H are NOT the same computation since H(P,I) and H1(P,I)
> return different values. DEFINITION.
>

I did not say that they are the same computation.
I said that my C/x86 H1 is to my C/x86 H as
the Linz H is to the Linz Ĥ

> If anything, this just proves that H isn't a computation, and that your
> static local variable did change the behavior of the H inside the P that
> is being decided.
>

My H1 differs from my H in that only the latter has the pathological
self-reference(Olcott 2004) error.

>>
>>> The key is that if we replace the 'Master UTM/halt decider' with an
>>> actual UTM that doesn't abort, but keep the rest of the system useing
>>> the original code, that 'slave' decider needs to act just like the
>>> master would have, and THAT determines the correct answer.
>>>
>>
>> The slave knows that it is not allowed to make a halt status decision
>> because a slave making such a decision would not be a pure function of
>> its input.
>
> But it MUST make the same decision from the trace that it IS allowed to
> see. If it changes its behavior because it sees it is a slave, it has
> broken the requirements.
>

The one key element that must be different between the master and the
slave is that only the master is allowed to request that memory be
allocated to store the execution trace, otherwise the execution trace
data keeps getting erased on every recursive simulation.

>>
>>> Of course we run into the problem that because you have broken the
>>> actual Computational Equivalence by having H^ call the exact same copy
>>> of H as is deciding it which can't actually be done by Turing Machines
>>> in the configuration required, you can't actually implement this in your
>>> C code.
>>>
>>
>> I can yet it makes my solution much more complex. After six months where
>> no one seems to have much of a slight glimmer of actual understanding
>> making my system more complex could only make understanding it
>> impossibly difficult.
>>
>
> It isn't the complexity. You have broken the rules but won't admit it,
> and try to hide it inside complexity.
>
> Your 'slaves' don't act just like the master, as in the master makes
> supposedly correct predictions based on the slaves acting differently
> then it does. This makes your code not a computation, and thus not
> eligable to be a decider.
>

The one key element that must be different between the master and the
slave is that only the master is allowed to request that memory be
allocated to store the execution trace, otherwise the execution trace
data keeps getting erased on every recursive simulation.

In the prior design the first slave that matched the infinite behavior
pattern reported its match and aborted the simulation of its input.
It reported that it aborted its simulation through another static local
variable. This causes all of the simulations to terminate.

--
Copyright 2021 Pete Olcott

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

Re: Why do theory of computation problems require pure functions?

<-oidnUk9zccCiNv8nZ2dnUU7-YGdnZ2d@giganews.com>

 copy mid

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

 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: Sat, 18 Sep 2021 11:36:47 -0500
Subject: Re: Why do theory of computation problems require pure functions?
Newsgroups: comp.theory
References: <a7WdnftR4JAUzNj8nZ2dnUU7-d_NnZ2d@giganews.com>
<si3r5q$8ln$1@dont-email.me> <KZSdncvVqtDkctj8nZ2dnUU7-f_NnZ2d@giganews.com>
<si4v0f$u4l$1@dont-email.me> <XMWdnTGSKtQenNv8nZ2dnUU7-LPNnZ2d@giganews.com>
<si5307$q3f$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
Date: Sat, 18 Sep 2021 11:36:45 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101
Thunderbird/78.14.0
MIME-Version: 1.0
In-Reply-To: <si5307$q3f$1@dont-email.me>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <-oidnUk9zccCiNv8nZ2dnUU7-YGdnZ2d@giganews.com>
Lines: 59
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-XaZYYvTCJ6A9R9MssJqtGdbPkufk+5TV0DljGk9JBwHx/42miKoCZAiYoW7r8K5nMTRUdXTkntpoTFy!1URmCsvFxpR4bZ0C1eHeTw0CdTSFL+yforGTbnUOjo7GyI2qfhAzrVvt+lWKXVgE0MjR9G1+ieTc!kX8=
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: 3638
 by: olcott - Sat, 18 Sep 2021 16:36 UTC

On 9/18/2021 11:09 AM, André G. Isaak wrote:
> On 2021-09-18 09:10, olcott wrote:
>> On 9/18/2021 10:01 AM, André G. Isaak wrote:
>>> On 2021-09-18 07:54, olcott wrote:
>
>>>> It still seems to be a pure function of its input in that
>>>> (1) The function return values are identical for identical arguments
>>>
>>> Except that it doesn't.
>>>
>>
>> For the purpose of this dialogue it is stipulated that it does, thus
>> even if it does not it is to be construed that it does.
>
> So your proof is going to rest on 'stipulating' that your program
> behaves in a way which it does not? I hate to break it to you, but
> that's not how proofs work. Otherwise, I could offer the following proof.
>

Richard seems to understand these things better than you do.

> (1) I stipulate that P = NP
> (2) Therefore P = NP
>
> How much money do do you think I should demand from the global ecommerce
> industry to keep this result secret from the world?
>
>> If we assume that all cats are dogs then the question:
>> Do cats bark is correctly anwered as: yes.
>
> Umm. No. It is not.
>
> For starters, not all dogs bark to begin with. So unless you also
> 'stipulate' that all dogs bark your conclusion doesn't follow.
>
> Secondly, and more importantly, your 'stipulation' isn't going to have
> any effect whatsoever on the behavior of my cat.
>
> When you stipulate counterfactuals, you leave open a huge range of
> possible interpretations: Are you envisioning an alternate universe in
> which cats behave differently? Or an alternate universe in which the
> word 'cat' refers to a different set of entities? Or an alternate
> universe in which there are no cats? Or, were it actually the case that
> all dogs bark, are you envisioning an alternate universe in which this
> is not the case? Or some other possibility altogether?
>
> Crucially, though, your 'stipulation' remains a counterfactual. It tells
> us nothing whatsoever about the *actual* universe, nor can it be used in
> a proof regarding the actual universe.
>
> André
>

--
Copyright 2021 Pete Olcott

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

Re: Why do theory of computation problems require pure functions?

<CtmdnXIC2u_Di9v8nZ2dnUU7-R3NnZ2d@giganews.com>

 copy mid

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

 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: Sat, 18 Sep 2021 11:39:58 -0500
Subject: Re: Why do theory of computation problems require pure functions?
Newsgroups: comp.theory
References: <a7WdnftR4JAUzNj8nZ2dnUU7-d_NnZ2d@giganews.com>
<si4khe$1nvt$1@gioia.aioe.org>
<mJmdnfaWlv7Kbdj8nZ2dnUU7-YHNnZ2d@giganews.com> <si4v6h$u4l$3@dont-email.me>
<Nc6dnYeBOsuRntv8nZ2dnUU7-QfNnZ2d@giganews.com> <si531f$q3f$2@dont-email.me>
From: NoO...@NoWhere.com (olcott)
Date: Sat, 18 Sep 2021 11:39:56 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101
Thunderbird/78.14.0
MIME-Version: 1.0
In-Reply-To: <si531f$q3f$2@dont-email.me>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <CtmdnXIC2u_Di9v8nZ2dnUU7-R3NnZ2d@giganews.com>
Lines: 39
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-FiM0qMqX9NwBFHBmBsNehcx9iqSnPmQDhwaiQ8ZRlTV0n+xonJCkrukwdeQn2ZaGsWSMpAvnT2rz93N!ikCgxuXdBfAya65epzyF8Qf6Eu0GqApdWrhmIoQK+eUPczc3tPrbmIZJjz+lbnK/IjpOlXB10vu/!jv4=
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: 2667
 by: olcott - Sat, 18 Sep 2021 16:39 UTC

On 9/18/2021 11:10 AM, André G. Isaak wrote:
> On 2021-09-18 09:17, olcott wrote:
>> On 9/18/2021 10:04 AM, André G. Isaak wrote:
>>> On 2021-09-18 07:57, olcott wrote:
>>>
>>>> I either must stick with C/x86 code or write a RASP machine, the
>>>> only way that my key insights can possible be fully understood is to
>>>> have every single detail as fully operational code such that we can
>>>> simply see what it does and thus not merely imagine what it would do.
>>>
>>> Why do you insist on continuously repeating this rather ridiculous
>>> claim?
>>>
>>> When working with Turing Machines one doesn't need to 'merely imagine
>>> what it would do.' One can see *exactly* what it does.
>>>
>>> André
>>>
>>
>> When H is defined as a simulating halt decider then H correctly
>> decides the halt status of ⟨Ĥ⟩ ⟨Ĥ⟩.
>
> And this statement relates to my post how exactly?
>
> André
>
>

How can [One can see *exactly* what it does] show that my claim that
simulating halt decider H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ does not correctly decide
the halt status of ⟨Ĥ⟩ ⟨Ĥ⟩ ?

--
Copyright 2021 Pete Olcott

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

Re: Why do theory of computation problems require pure functions?

<yo-dnfxINuFThdv8nZ2dnUU7-a_NnZ2d@giganews.com>

 copy mid

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

 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: Sat, 18 Sep 2021 11:50:21 -0500
Subject: Re: Why do theory of computation problems require pure functions?
Newsgroups: comp.theory
References: <a7WdnftR4JAUzNj8nZ2dnUU7-d_NnZ2d@giganews.com>
<si4khe$1nvt$1@gioia.aioe.org>
<mJmdnfaWlv7Kbdj8nZ2dnUU7-YHNnZ2d@giganews.com> <si4v6h$u4l$3@dont-email.me>
<Nc6dnYeBOsuRntv8nZ2dnUU7-QfNnZ2d@giganews.com>
<Awn1J.130330$o45.49337@fx46.iad> <si50lp$960$2@dont-email.me>
<PIn1J.39327$2Q_3.774@fx35.iad>
<goidnch2gvbNldv8nZ2dnUU7-QmdnZ2d@giganews.com>
<_Wn1J.168986$T_8.81874@fx48.iad>
<2f6dnYwdyrUFjdv8nZ2dnUU7-dHNnZ2d@giganews.com>
<4to1J.96063$Kv2.76439@fx47.iad>
From: NoO...@NoWhere.com (olcott)
Date: Sat, 18 Sep 2021 11:50:19 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101
Thunderbird/78.14.0
MIME-Version: 1.0
In-Reply-To: <4to1J.96063$Kv2.76439@fx47.iad>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <yo-dnfxINuFThdv8nZ2dnUU7-a_NnZ2d@giganews.com>
Lines: 131
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-jgicu1AQfEBFl7TLNMRIu6PRq6+YU1Dql37B1ZgzzNH9zLgoEubhr/448yR+4b521YTJbXAlmEBTzJp!UkVZze5FRIuXGBT+IP3kFcT15Z9Rj3sanA2sC/uHVDWUSPsljd0s9hq5YfMEZ4wCkvtXfSNIWQ0h!tWc=
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: 6593
 by: olcott - Sat, 18 Sep 2021 16:50 UTC

On 9/18/2021 11:28 AM, Richard Damon wrote:
> On 9/18/21 12:15 PM, olcott wrote:
>> On 9/18/2021 10:52 AM, Richard Damon wrote:
>>> On 9/18/21 11:39 AM, olcott wrote:
>>>> On 9/18/2021 10:37 AM, Richard Damon wrote:
>>>>> On 9/18/21 11:29 AM, olcott wrote:
>>>>>> On 9/18/2021 10:24 AM, Richard Damon wrote:
>>>>>>> On 9/18/21 11:17 AM, olcott wrote:
>>>>>>>> On 9/18/2021 10:04 AM, André G. Isaak wrote:
>>>>>>>>> On 2021-09-18 07:57, olcott wrote:
>>>>>>>>>
>>>>>>>>>> I either must stick with C/x86 code or write a RASP machine, the
>>>>>>>>>> only
>>>>>>>>>> way that my key insights can possible be fully understood is to
>>>>>>>>>> have
>>>>>>>>>> every single detail as fully operational code such that we can
>>>>>>>>>> simply
>>>>>>>>>> see what it does and thus not merely imagine what it would do.
>>>>>>>>>
>>>>>>>>> Why do you insist on continuously repeating this rather ridiculous
>>>>>>>>> claim?
>>>>>>>>>
>>>>>>>>> When working with Turing Machines one doesn't need to 'merely
>>>>>>>>> imagine
>>>>>>>>> what it would do.' One can see *exactly* what it does.
>>>>>>>>>
>>>>>>>>> André
>>>>>>>>>
>>>>>>>>
>>>>>>>> When H is defined as a simulating halt decider then H correctly
>>>>>>>> decides
>>>>>>>> the halt status of ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>>>>
>>>>>>>> https://www.liarparadox.org/Peter_Linz_HP(Pages_315-320).pdf
>>>>>>>>
>>>>>>>
>>>>>>> Except that it doesn't, as H says H^(H^) is non-halting when it
>>>>>>> actually
>>>>>>> Halts.
>>>>>>>
>>>>>>
>>>>>> H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to H.qy.
>>>>>>
>>>>>
>>>>> Which says that it is deciding that H^(<H^>) is a non-halting
>>>>> computation, but if we run H^(<H^>) it ends up at its terminal state
>>>>> H^.qy which halts. (Since the code for H^ is derived from the code
>>>>> of H,
>>>>> and the state H^.qn is the corresponding state to H.qn)
>>>>>
>>>>
>>>> So does my use of a static local variable by itself make my code not
>>>> apply to the halting problem or not?
>>>>
>>>
>>> No, but that doesn't mean that the presence of the static local variable
>>> is unconditionally allowed.
>>>
>>> You need to PROVE that your program is a Computation.
>>>
>>> Lack of things like static local variables make that proof much easier.
>>> as if all information inside the program can only be derived from the
>>> official input, then there is no source of 'illegal' information.
>>>
>>
>> The halt status decision is entirely based on the execution trace
>> derived from the input machine address pair.
>
> Right, but that ALSO applies to the simulated copies of H, which need to
> give the exact same answer given the exact same input.
>

The original way that it worked was that the very first slave that saw
that an infinite behavior pattern was matched reported this through a
static variable that every master/slave instance of H used as their
while (**Aborted == 0) termination condition.

Then I changed this so that only the master made the halt status
decision. Its trigger for testing the halt status was that the local
static execution trace is longer than it was the last time that it
tested the halt status.

> This means that since the 'master' H(P,P) returns non-halting, that must
> be consistent with the copy of H inside P ALSO return the answer of
> non-halting when given that exact same input.
>
> The 'assumption' that it will not return is a violation of that.
>
> Either H is using unsound logic, or H is not a computation because the
> 'slave' H doesn't behave the same way.
>
>>
>>> Presence of things like static local variables don't by themselves
>>> invalidate you ability to be a Computation, but do mean you really do
>>> need to show that it is one.
>>>
>>
>> That is great. What are the requirements of a computation?
>>
>> given an input of the function domain it can return the corresponding
>> output. https://en.wikipedia.org/wiki/Computable_function
>
> It is a bit more that a function with a specific value for a specific
> input, as it also needs to be the results of an 'algorithm', a step by
> step listing of instructions to get to the result.
>
> If all of the inputs to the algorithm are part of the formal input to
> the function, then you get a computation.
>

Formal input is typically restricted to input parameters.
The use of the static local execution_trace is to store intermediate
results that are derived on the basis of the input parameters.

>>
>>> So, as of now, the proposition that your code is eligible to be a
>>> decider is unproven, and can not just be 'assumed'
>>>
>>> If we ever see a case where two copies of H given the same input act
>>> differently, then this statement is proved in the negative.
>>>
>>
>>
>

--
Copyright 2021 Pete Olcott

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

Re: Why do theory of computation problems require pure functions?

<si55gs$aa2$1@dont-email.me>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: agis...@gm.invalid (André G. Isaak)
Newsgroups: comp.theory
Subject: Re: Why do theory of computation problems require pure functions?
Date: Sat, 18 Sep 2021 10:52:44 -0600
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 44
Message-ID: <si55gs$aa2$1@dont-email.me>
References: <a7WdnftR4JAUzNj8nZ2dnUU7-d_NnZ2d@giganews.com>
<si4khe$1nvt$1@gioia.aioe.org>
<mJmdnfaWlv7Kbdj8nZ2dnUU7-YHNnZ2d@giganews.com> <si4v6h$u4l$3@dont-email.me>
<Nc6dnYeBOsuRntv8nZ2dnUU7-QfNnZ2d@giganews.com> <si531f$q3f$2@dont-email.me>
<CtmdnXIC2u_Di9v8nZ2dnUU7-R3NnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sat, 18 Sep 2021 16:52:45 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="b2780b02a2648bf8f0dad6d21eb6aca0";
logging-data="10562"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1+xd5N8eEv2+9LC9ULrtiNB"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:68.0)
Gecko/20100101 Thunderbird/68.12.1
Cancel-Lock: sha1:ANTvXNSSS4NF+tA6fjtmWZn2EI0=
In-Reply-To: <CtmdnXIC2u_Di9v8nZ2dnUU7-R3NnZ2d@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Sat, 18 Sep 2021 16:52 UTC

On 2021-09-18 10:39, olcott wrote:
> On 9/18/2021 11:10 AM, André G. Isaak wrote:
>> On 2021-09-18 09:17, olcott wrote:
>>> On 9/18/2021 10:04 AM, André G. Isaak wrote:
>>>> On 2021-09-18 07:57, olcott wrote:
>>>>
>>>>> I either must stick with C/x86 code or write a RASP machine, the
>>>>> only way that my key insights can possible be fully understood is
>>>>> to have every single detail as fully operational code such that we
>>>>> can simply see what it does and thus not merely imagine what it
>>>>> would do.
>>>>
>>>> Why do you insist on continuously repeating this rather ridiculous
>>>> claim?
>>>>
>>>> When working with Turing Machines one doesn't need to 'merely
>>>> imagine what it would do.' One can see *exactly* what it does.
>>>>
>>>> André
>>>>
>>>
>>> When H is defined as a simulating halt decider then H correctly
>>> decides the halt status of ⟨Ĥ⟩ ⟨Ĥ⟩.
>>
>> And this statement relates to my post how exactly?
>>
>> André
>>
>>
>
> How can [One can see *exactly* what it does] show that my claim that
> simulating halt decider H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ does not correctly decide
> the halt status of ⟨Ĥ⟩ ⟨Ĥ⟩ ?

I made no claims whatsoever in my post about your H. I questioned your
repeated assertion that if you don't have fully operational c/x86 code
you have to imagine all the details. You keep asserting that with Turing
Machine you must 'imagine' all the details which is simply false.

André

--
To email remove 'invalid' & replace 'gm' with well known Google mail
service.

Re: Why do theory of computation problems require pure functions?

<0fKdndonloWPgdv8nZ2dnUU7-KnNnZ2d@giganews.com>

 copy mid

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

 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: Sat, 18 Sep 2021 12:04:18 -0500
Subject: Re: Why do theory of computation problems require pure functions?
Newsgroups: comp.theory
References: <a7WdnftR4JAUzNj8nZ2dnUU7-d_NnZ2d@giganews.com>
<si3r5q$8ln$1@dont-email.me> <KZSdncvVqtDkctj8nZ2dnUU7-f_NnZ2d@giganews.com>
<ZVm1J.3937$7U3.2717@fx24.iad>
<j8adnV6gzfcKYdj8nZ2dnUU7-V3NnZ2d@giganews.com>
<lmn1J.84222$jl2.75920@fx34.iad>
<Nc6dnYaBOsvxntv8nZ2dnUU7-QednZ2d@giganews.com>
<Cxn1J.130331$o45.17922@fx46.iad>
<goidncl2gvYjmtv8nZ2dnUU7-QnNnZ2d@giganews.com>
<gPn1J.36462$ol1.15837@fx42.iad>
<qYmdneD7KY-Pktv8nZ2dnUU7-YHNnZ2d@giganews.com>
<Swo1J.31123$nR3.24966@fx38.iad>
From: NoO...@NoWhere.com (olcott)
Date: Sat, 18 Sep 2021 12:04:16 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101
Thunderbird/78.14.0
MIME-Version: 1.0
In-Reply-To: <Swo1J.31123$nR3.24966@fx38.iad>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <0fKdndonloWPgdv8nZ2dnUU7-KnNnZ2d@giganews.com>
Lines: 294
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-5lb228l9uxZ/qgJRaZGJtH3NrAKxFCQeNqnI09ra/GwM418Pko2h7l5KaGCu/4LxS8/rKv2eazJrkki!j/wBs5SaTAh4zRc8LX0Gt5gfqMGwC7+BuH63xA/SnM1JeqKvBLv0oNAKsH2NY2NrOiN/QaaSKidl!oEM=
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: 13771
 by: olcott - Sat, 18 Sep 2021 17:04 UTC

On 9/18/2021 11:32 AM, Richard Damon wrote:
> On 9/18/21 12:08 PM, olcott wrote:
>> On 9/18/2021 10:44 AM, Richard Damon wrote:
>>> On 9/18/21 11:37 AM, olcott wrote:
>>>> On 9/18/2021 10:25 AM, Richard Damon wrote:
>>>>> On 9/18/21 11:19 AM, olcott wrote:
>>>>>> On 9/18/2021 10:13 AM, Richard Damon wrote:
>>>>>>> On 9/18/21 10:49 AM, olcott wrote:
>>>>>>>> On 9/18/2021 9:43 AM, Richard Damon wrote:
>>>>>>>>>
>>>>>>>>> On 9/18/21 9:54 AM, olcott wrote:
>>>>>>>>>> On 9/17/2021 11:50 PM, André G. Isaak wrote:
>>>>>>>>>>> On 2021-09-17 20:40, olcott wrote:
>>>>>>>>>>>> Why do theory of computation problems require pure functions?
>>>>>>>>>>>
>>>>>>>>>>> Because the theory of computation isn't about C or x86. It isn't
>>>>>>>>>>> about
>>>>>>>>>>> computer programs at all, nor about modern computers. Just
>>>>>>>>>>> because
>>>>>>>>>>> 'computation' and 'computer' share the same root doesn't mean
>>>>>>>>>>> they
>>>>>>>>>>> deal with the same set of phenomena. Remember that the theory of
>>>>>>>>>>> computation developed before there even were digital computers or
>>>>>>>>>>> programming languages.
>>>>>>>>>>>
>>>>>>>>>>> Computational theory is concerned with describing *mathematical*
>>>>>>>>>>> functions, and all mathematical functions are pure functions. A
>>>>>>>>>>> computation is a method for determining the value of the
>>>>>>>>>>> mathematical
>>>>>>>>>>> function f(x) for a given x. A computable function is one for
>>>>>>>>>>> which it
>>>>>>>>>>> is possible to construct a TM which, given an input string
>>>>>>>>>>> representing x, will determine the value of f(x).
>>>>>>>>>>>
>>>>>>>>>>> You can write computer programs which perform computations,
>>>>>>>>>>> but the
>>>>>>>>>>> majority of computer programs don't.
>>>>>>>>>>>
>>>>>>>>>>> If you really want to learn about the theory of computation, I'd
>>>>>>>>>>> suggest that you forget about C or x86 assembly or any sort of
>>>>>>>>>>> computer language altogether and focus on Turing Machines.
>>>>>>>>>>>
>>>>>>>>>>> And don't try to mentally translate anything you read about
>>>>>>>>>>> Turing
>>>>>>>>>>> Machines into computer languages. Don't think about loop
>>>>>>>>>>> counters, or
>>>>>>>>>>> calls, or machine addresses, because all of these things
>>>>>>>>>>> pertain to
>>>>>>>>>>> computers and computer programming rather than computations and
>>>>>>>>>>> they
>>>>>>>>>>> will get in the way of you actually understanding either turing
>>>>>>>>>>> machines or the theory of computation more generally.
>>>>>>>>>>>
>>>>>>>>>>> André
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> I only need to know this for one reason.
>>>>>>>>>>
>>>>>>>>>> When my halt decider is examining the behavior of its input and
>>>>>>>>>> the
>>>>>>>>>> input calls this halt decider in infinite recursion it cannot keep
>>>>>>>>>> track
>>>>>>>>>> of the behavior of this input without having a single pseudo
>>>>>>>>>> static
>>>>>>>>>> variable that is directly embedded in its machine code.
>>>>>>>>>>
>>>>>>>>>> This pseudo static variable stores the ongoing execution trace.
>>>>>>>>>> When the
>>>>>>>>>> variable is an ordinary local variable it loses all of its data
>>>>>>>>>> between
>>>>>>>>>> each recursive simulation.
>>>>>>>>>>
>>>>>>>>>> It still seems to be a pure function of its input in that
>>>>>>>>>> (1) The function return values are identical for identical
>>>>>>>>>> arguments
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> I think the key issue is that if you want to talk about the plain
>>>>>>>>> behavior of C / x86 code, then you need to talk about the ACTUAL
>>>>>>>>> behavior of that code, which means that the call to H within the
>>>>>>>>> simulated machine needs to be seen as a call to H, and NOT some
>>>>>>>>> logical
>>>>>>>>> transformation.
>>>>>>>>>
>>>>>>>>> If you want to do the transformation, your need to actually PROVE
>>>>>>>>> that
>>>>>>>>> this transform is legitimate under the conditions you want to make
>>>>>>>>> it,
>>>>>>>>> and that needs a very FORMAL argument based on accepted truths and
>>>>>>>>> principles. Your 'argument' based on H not affecting P until
>>>>>>>>> after it
>>>>>>>>> makes its decision so it can ignore its effect, is one of those
>>>>>>>>> arguments that just seems 'obvious' but you haven't actually
>>>>>>>>> proved it.
>>>>>>>>> You don't seem to uhderstand that nature of how to prove something
>>>>>>>>> like
>>>>>>>>> this.
>>>>>>>>>
>>>>>>>>> 'Obvious' things can be wrong, like it seems obvious that the
>>>>>>>>> order you
>>>>>>>>> add up a series shouldn't affect the result, even if the number of
>>>>>>>>> terms
>>>>>>>>> in infinite, but there are simple proofs to show that for SOME
>>>>>>>>> infinite
>>>>>>>>> sums, the order you take the terms can make a difference,
>>>>>>>>> dispite it
>>>>>>>>> seeming contrary to the nature of addition (infinities break a
>>>>>>>>> lot of
>>>>>>>>> common sense).
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> A key point about your 'static' variable problem.
>>>>>>>>
>>>>>>>> There is only a single question here, not the myriad of questions
>>>>>>>> that
>>>>>>>> you refer to.
>>>>>>>>
>>>>>>>> Does my use of a single static variable that holds the ongoing
>>>>>>>> execution
>>>>>>>> trace by itself necessarily completely disqualify my system from
>>>>>>>> applying to the halting problem or not?
>>>>>>>>
>>>>>>>> a) Yes
>>>>>>>> b) No
>>>>>>>
>>>>>>> Error of the Complex Question, just like the question of "Have you
>>>>>>> stopped lying about your Halt Decider?".
>>>>>>>
>>>>>>> It isn't the existence of a static variable itself that might
>>>>>>> disqualify
>>>>>>> your system for applying to the halting problem,
>>>>>>
>>>>>> André disagrees so one of you must be wrong.
>>>>>
>>>>> Then take his answer and go away as you admit defeat.
>>>>>
>>>>
>>>> That is not how categorically exhaustive reasoning works. Categorically
>>>> exhaustive reasoning eliminates the possibility of the error of
>>>> omission. It results in limited subject domain omniscience.
>>>>
>>>> It only stops when
>>>> (1) A solution is found.
>>>> (2) No solution exist within omniscience.
>>>
>>> But your question, as I explained, was not categorically exhaustive.
>>>
>>
>> Polar (yes/no) questions only have {yes, no} answers.
>> {yes,no} completely exhausts the entire category of answers to polar
>> (yes/no) questions.
>
> As long as you take the answer only for the question exactly as asked.
>
> No, the presence of a static local variable doesn't IN ITSELF disqualify
> a piece of code from being a Computation, but does greatly increase the
> possibility that it is not.
>
>>
>>> Have you stopped lying about your Halt Decider?
>>
>> To the best of my knowledge I have only actually lied once in the last
>> ten years. I lied to a close friend about a very hurtful truth to
>> protect them from this very hurtful truth.
>
> Since it has been reported that you claimed years ago that you did have
> a version of your Halt Decider totally coded as a ACTUAL Turing Machine,
> and you have since retracted that statement, wasn't the first statement
> a LIE.
>


Click here to read the complete article
Re: Why do theory of computation problems require pure functions?

<L5-dnUtHucSVgNv8nZ2dnUU7-X_NnZ2d@giganews.com>

 copy mid

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

 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: Sat, 18 Sep 2021 12:08:24 -0500
Subject: Re: Why do theory of computation problems require pure functions?
Newsgroups: comp.theory
References: <a7WdnftR4JAUzNj8nZ2dnUU7-d_NnZ2d@giganews.com>
<si4khe$1nvt$1@gioia.aioe.org>
<mJmdnfaWlv7Kbdj8nZ2dnUU7-YHNnZ2d@giganews.com> <si4v6h$u4l$3@dont-email.me>
<Nc6dnYeBOsuRntv8nZ2dnUU7-QfNnZ2d@giganews.com> <si531f$q3f$2@dont-email.me>
<CtmdnXIC2u_Di9v8nZ2dnUU7-R3NnZ2d@giganews.com> <si55gs$aa2$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
Date: Sat, 18 Sep 2021 12:08:23 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101
Thunderbird/78.14.0
MIME-Version: 1.0
In-Reply-To: <si55gs$aa2$1@dont-email.me>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <L5-dnUtHucSVgNv8nZ2dnUU7-X_NnZ2d@giganews.com>
Lines: 61
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-UF9eM1beiizJZo1tcDgkbiIwjtwg5132P0ageTPp3ZQ+wwVBQnz6vAbeboaiOdZYLqkv1snSfsvLsKB!u62V/OpAKBBVDvgTAGkWHFzJipnxeQbgrln9n+nmVmcAxsCOtDppWsBKdlNIPTOgLPe70glD4jhJ!JFQ=
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: 3534
 by: olcott - Sat, 18 Sep 2021 17:08 UTC

On 9/18/2021 11:52 AM, André G. Isaak wrote:
> On 2021-09-18 10:39, olcott wrote:
>> On 9/18/2021 11:10 AM, André G. Isaak wrote:
>>> On 2021-09-18 09:17, olcott wrote:
>>>> On 9/18/2021 10:04 AM, André G. Isaak wrote:
>>>>> On 2021-09-18 07:57, olcott wrote:
>>>>>
>>>>>> I either must stick with C/x86 code or write a RASP machine, the
>>>>>> only way that my key insights can possible be fully understood is
>>>>>> to have every single detail as fully operational code such that we
>>>>>> can simply see what it does and thus not merely imagine what it
>>>>>> would do.
>>>>>
>>>>> Why do you insist on continuously repeating this rather ridiculous
>>>>> claim?
>>>>>
>>>>> When working with Turing Machines one doesn't need to 'merely
>>>>> imagine what it would do.' One can see *exactly* what it does.
>>>>>
>>>>> André
>>>>>
>>>>
>>>> When H is defined as a simulating halt decider then H correctly
>>>> decides the halt status of ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>
>>> And this statement relates to my post how exactly?
>>>
>>> André
>>>
>>>
>>
>> How can [One can see *exactly* what it does] show that my claim that
>> simulating halt decider H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ does not correctly decide
>> the halt status of ⟨Ĥ⟩ ⟨Ĥ⟩ ?
>
> I made no claims whatsoever in my post about your H.

This is exactly what I mean by dishonest dodge AKA the strawman error.

When we examine the Peter Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩

there is nothing in the peter Linz text where
[One can see *exactly* what it does]

when we assume that the Peter Linz H/Ĥ are based on simulating halt
deciders.

> I questioned your
> repeated assertion that if you don't have fully operational c/x86 code
> you have to imagine all the details. You keep asserting that with Turing
> Machine you must 'imagine' all the details which is simply false.
>
> André
>

--
Copyright 2021 Pete Olcott

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

Re: Why do theory of computation problems require pure functions?

<si57qi$s92$1@dont-email.me>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!paganini.bofh.team!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: jbb...@notatt.com (Jeff Barnett)
Newsgroups: comp.theory
Subject: Re: Why do theory of computation problems require pure functions?
Date: Sat, 18 Sep 2021 11:31:57 -0600
Organization: A noiseless patient Spider
Lines: 66
Message-ID: <si57qi$s92$1@dont-email.me>
References: <a7WdnftR4JAUzNj8nZ2dnUU7-d_NnZ2d@giganews.com>
<si3r5q$8ln$1@dont-email.me> <KZSdncvVqtDkctj8nZ2dnUU7-f_NnZ2d@giganews.com>
<ZVm1J.3937$7U3.2717@fx24.iad>
<j8adnV6gzfcKYdj8nZ2dnUU7-V3NnZ2d@giganews.com> <si4v1h$u4l$2@dont-email.me>
<rvn1J.130329$o45.114860@fx46.iad> <si5458$2de$1@dont-email.me>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: quoted-printable
Injection-Date: Sat, 18 Sep 2021 17:32:02 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="1b7827382ecccdf8c22e95591d3f0932";
logging-data="28962"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1+YtQxe8NJ7ZiDxIpPS2sW4LGH8xIvkbD8="
User-Agent: Mozilla/5.0 (Windows NT 6.1; Win64; x64; rv:78.0) Gecko/20100101
Thunderbird/78.14.0
Cancel-Lock: sha1:aUMLQOQIisr9r/6De7ERr4kIZMM=
In-Reply-To: <si5458$2de$1@dont-email.me>
Content-Language: en-US
 by: Jeff Barnett - Sat, 18 Sep 2021 17:31 UTC

On 9/18/2021 10:29 AM, André G. Isaak wrote:
> On 2021-09-18 09:23, Richard Damon wrote:
>> On 9/18/21 11:02 AM, André G. Isaak wrote:
>>> On 2021-09-18 08:49, olcott wrote:
>>>> On 9/18/2021 9:43 AM, Richard Damon wrote:
>>>
>>>> Does my use of a single static variable that holds the ongoing
>>>> execution trace by itself necessarily completely disqualify my system
>>>> from applying to the halting problem or not?
>>>>
>>>> a) Yes
>>>> b) No
>>>
>>> (a) Yes.
>>>
>>> André
>>>
>>
>> That is incorrect, as it is quite possible to have a program that IS a
>> computation that still has a static variable, it a categorical No can be
>> disproven.
>
> Perhaps a better way of putting it would be that if a function
> absolutely *requires* a static variable to achieve the desired result,
> then it does not represent a computation.
>
> I went with (a) because Olcott is incapable of processing answers which
> include anything resembling 'details' or 'nuance'. All answers must be
> completely black and white.

I will point out that there was a serious flaw within one of the early
ALGOL specs: there was an ambiguity about when a "new" own binding
should be created. There was a famous little program that exhibited
different behavior depending on the interpretation used for owns. Under
one interpretation it computed a Legendre polynomial and a Jacobi
polynomial under another. (Note, I may have the polynomial class names
confused.) There where compilers implemented with each interpretation
and some discussions finally spotted the spec problem.

A computation can be implemented with an own (= static) that is used
within it, e.g., a static for an instantiation of an object. N.B. That a
computation, by definition, cannot be reused or reentered. In fact, a
computation can do virtually anything within its self. The PO problem is
that he insists on putting a non functioning boundary around what he
calls a computation.

One other non novel observation: the use of any variable/binding is
equivalent in many senses to the use of a static/own. It all depends on
how you describe the rules/semantics of the program execution.

In other words, "What we have been calling a computation must be like a
function in that its behavior is repeatable. It is not necessary that
its interior implementation be of purely functional parts; that illusion
must only be maintained in the description at its exterior boundary."
--
Jeff Barnett

Re: Why do theory of computation problems require pure functions?

<KpadnesY08Oxu9v8nZ2dnUU7-evNnZ2d@giganews.com>

 copy mid

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

 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: Sat, 18 Sep 2021 12:47:23 -0500
Subject: Re: Why do theory of computation problems require pure functions?
Newsgroups: comp.theory
References: <a7WdnftR4JAUzNj8nZ2dnUU7-d_NnZ2d@giganews.com>
<si3r5q$8ln$1@dont-email.me> <KZSdncvVqtDkctj8nZ2dnUU7-f_NnZ2d@giganews.com>
<ZVm1J.3937$7U3.2717@fx24.iad>
<j8adnV6gzfcKYdj8nZ2dnUU7-V3NnZ2d@giganews.com> <si4v1h$u4l$2@dont-email.me>
<rvn1J.130329$o45.114860@fx46.iad> <si5458$2de$1@dont-email.me>
<si57qi$s92$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
Date: Sat, 18 Sep 2021 12:47:22 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101
Thunderbird/78.14.0
MIME-Version: 1.0
In-Reply-To: <si57qi$s92$1@dont-email.me>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <KpadnesY08Oxu9v8nZ2dnUU7-evNnZ2d@giganews.com>
Lines: 71
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-RRiU21RdI4u9YY2s6WypMKZEdiA5tDkqybY198FGX/TBHiNf7p5f6Ih88TP7GCrjNE0BHByxaUo19KD!ZN5XhpEoO29jvzkBoPjtrF8Df7/bCLWWg0IyDRtSdn+DvpIz4n7AyahAvmlcR48QowPt+Va7kAw8!iZg=
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: 4638
 by: olcott - Sat, 18 Sep 2021 17:47 UTC

On 9/18/2021 12:31 PM, Jeff Barnett wrote:
> On 9/18/2021 10:29 AM, André G. Isaak wrote:
>> On 2021-09-18 09:23, Richard Damon wrote:
>>> On 9/18/21 11:02 AM, André G. Isaak wrote:
>>>> On 2021-09-18 08:49, olcott wrote:
>>>>> On 9/18/2021 9:43 AM, Richard Damon wrote:
>>>>
>>>>> Does my use of a single static variable that holds the ongoing
>>>>> execution trace by itself necessarily completely disqualify my system
>>>>> from applying to the halting problem or not?
>>>>>
>>>>> a) Yes
>>>>> b) No
>>>>
>>>> (a) Yes.
>>>>
>>>> André
>>>>
>>>
>>> That is incorrect, as it is quite possible to have a program that IS a
>>> computation that still has a static variable, it a categorical No can be
>>> disproven.
>>
>> Perhaps a better way of putting it would be that if a function
>> absolutely *requires* a static variable to achieve the desired result,
>> then it does not represent a computation.
>>
>> I went with (a) because Olcott is incapable of processing answers
>> which include anything resembling 'details' or 'nuance'. All answers
>> must be completely black and white.
>
> I will point out that there was a serious flaw within one of the early
> ALGOL specs: there was an ambiguity about when a "new" own binding
> should be created. There was a famous little program that exhibited
> different behavior depending on the interpretation used for owns. Under
> one interpretation it computed a Legendre polynomial and a Jacobi
> polynomial under another. (Note, I may have the polynomial class names
> confused.) There where compilers implemented with each interpretation
> and some discussions finally spotted the spec problem.
>
> A computation can be implemented with an own (= static) that is used
> within it, e.g., a static for an instantiation of an object. N.B. That a
> computation, by definition, cannot be reused or reentered.

In order for H to be able to see that itself is being called in
infinitely nested simulation it must be able to maintain the execution
trace of its input that is not erased between nested simulations of
itself. This is currently achieved using a variable that is directly
stored in its own machine code. Every nested simulation of itself has
access to this variable.

> In fact, a
> computation can do virtually anything within its self. The PO problem is
> that he insists on putting a non functioning boundary around what he
> calls a computation.
>
> One other non novel observation: the use of any variable/binding is
> equivalent in many senses to the use of a static/own. It all depends on
> how you describe the rules/semantics of the program execution.
>
> In other words, "What we have been calling a computation must be like a
> function in that its behavior is repeatable. It is not necessary that
> its interior implementation be of purely functional parts; that illusion
> must only be maintained in the description at its exterior boundary."

--
Copyright 2021 Pete Olcott

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

Pages:12345678910
server_pubkey.txt

rocksolid light 0.9.7
clearnet tor