Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  nodelist  faq  login

Deliver yesterday, code today, think tomorrow.


computers / comp.ai.philosophy / Re: Why do theory of computation problems require pure functions? [ computation ? ]

SubjectAuthor
* Why do theory of computation problems require pure functions?olcott
+* Re: Why do theory of computation problems require pure functions?olcott
|`- Re: Why do theory of computation problems require pure functions?olcott
`* Re: Why do theory of computation problems require pure functions?olcott
 +* Re: Why do theory of computation problems require pure functions?olcott
 |+- Re: Why do theory of computation problems require pure functions?[ decidabolcott
 |`* Re: Why do theory of computation problems require pure functions? [olcott
 | `* Re: Why do theory of computation problems require pure functions? [olcott
 |  +- Re: Why do theory of computation problems require pure functions? [Jeff Barnett
 |  `* Re: Why do theory of computation problems require pure functions? [olcott
 |   `- Re: Why do theory of computation problems require pure functions? [ PSR erolcott
 +* Re: Why do theory of computation problems require pure functions?olcott
 |`- Re: Why do theory of computation problems require pure functions?olcott
 `- Re: Why do theory of computation problems require pure functions? [olcott

1
Subject: Why do theory of computation problems require pure functions?
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic, sci.math
Date: Sat, 18 Sep 2021 02:40 UTC
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: Fri, 17 Sep 2021 21:40:09 -0500
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
X-Mozilla-News-Host: news://news.giganews.com:119
From: NoO...@NoWhere.com (olcott)
Subject: Why do theory of computation problems require pure functions?
Date: Fri, 17 Sep 2021 21:40:09 -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
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 7bit
Message-ID: <a7WdnftR4JAUzNj8nZ2dnUU7-d_NnZ2d@giganews.com>
Lines: 23
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-GZ8BBpnoSr4EnH908hCpre+c5mCskoj8RMbS9f2+rikpDxYpNC3uyBdShVRBv1HltRX//b7jD9MXMqf!rymZd6XanUR5AvwOEcgTu6DCmucBi2saPKVxTLK9zP/woy67irPLglkcz17XXhyEm4uum+u0VS+I!4ks=
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: 2032
View all headers
Why do theory of computation problems require pure functions?

I am trying to write C code that would be acceptable to computer scientists in the field of the theory of computation.

In computer programming, a pure function is a function that has the following properties:

(1) The function return values are identical for identical arguments (no variation with local static variables, non-local variables, mutable reference arguments or input streams).

(2) The function application has no side effects (no mutation of local static variables, non-local variables, mutable reference arguments or input/output streams).

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

--
Copyright 2021 Pete Olcott

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


Subject: Re: Why do theory of computation problems require pure functions?
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic, sci.math
Date: Sat, 18 Sep 2021 13:54 UTC
References: 1 2
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 08:54:01 -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>
From: NoO...@NoWhere.com (olcott)
Date: Sat, 18 Sep 2021 08:54:00 -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: <si3r5q$8ln$1@dont-email.me>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <KZSdncvVqtDkctj8nZ2dnUU7-f_NnZ2d@giganews.com>
Lines: 54
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-TqTHw2S+laJZwkNKk95W2qHFjK+pJMLJ9p84r54AeodOem2rmSkbCn+D5xV77U2PkHBPEulPJ4gdcOf!ofVKbXOqh1XG++Q14wSFMjoCWJqLAjs6HvFCR/bQfyFOfQ4CEhIuL9srWD+LW4pcBcLSPWO7fasd!12w=
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: 3736
View all headers
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

--
Copyright 2021 Pete Olcott

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


Subject: Re: Why do theory of computation problems require pure functions?
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic, sci.math
Date: Sat, 18 Sep 2021 16:08 UTC
References: 1 2 3 4 5 6 7 8 9 10
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
View all headers
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:

Revelation 21:8 KJV ...all liars, shall have their part in the lake which burneth with fire and brimstone: which is the second death.

If we take that verse literally then to err on the safe side one should refrain from all lies great and small.




   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.












--
Copyright 2021 Pete Olcott

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


Subject: Re: Why do theory of computation problems require pure functions?
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.math, sci.logic
Date: Sat, 18 Sep 2021 22:15 UTC
References: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
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 17:15:59 -0500
Subject: Re: Why do theory of computation problems require pure functions?
Newsgroups: comp.theory,comp.ai.philosophy,sci.math,sci.logic
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>
<L5-dnUtHucSVgNv8nZ2dnUU7-X_NnZ2d@giganews.com>
<12r1J.107151$lC6.16042@fx41.iad>
<caKdncaNf93r3dv8nZ2dnUU7-UfNnZ2d@giganews.com>
<axr1J.55095$jm6.40535@fx07.iad>
<4dqdnW74K8nv1Nv8nZ2dnUU7-d2dnZ2d@giganews.com>
<Sds1J.75975$z%4.33404@fx37.iad>
<0LKdnQW0_vXAz9v8nZ2dnUU7-RHNnZ2d@giganews.com> <si5o18$ca0$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
Date: Sat, 18 Sep 2021 17:15:51 -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: <si5o18$ca0$1@dont-email.me>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <b8qdnUQWUNeC-Nv8nZ2dnUU7-cvNnZ2d@giganews.com>
Lines: 229
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-TjZc9Lg2CyAddLTPRA8I8BndgIfWwWqsQvxYMCKNHHNCSylViyEYf85Tahu5IooSD8QLvZgNrFONBVd!NihHiV0F4y/f2vI1bWqClAAJF0emKXVMf975Rb2ObY72e4sQ9ehyuMnjTzTYnpFE4i3gZfkZrqRM!nmQ=
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: 11008
View all headers
On 9/18/2021 5:08 PM, André G. Isaak wrote:
On 2021-09-18 14:55, olcott wrote:
On 9/18/2021 3:45 PM, Richard Damon wrote:
On 9/18/21 4:17 PM, olcott wrote:
On 9/18/2021 2:57 PM, Richard Damon wrote:
On 9/18/21 3:39 PM, olcott wrote:
On 9/18/2021 2:24 PM, Richard Damon wrote:
On 9/18/21 1:08 PM, olcott wrote:
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.

In the Linz text, we are not given the detail of what the machines do
inside for their processing, but we know EXACTLY how they behave at an
input/output level.

H is given a defined input, a properly encoded version of H^ (<H^>)

and is defined to end, based on whatever algorithm is inside H to
end at
either H.qy or H.qn.

He then defines a machine H^ that is based on a nearly exact copy of H,
with just a minor change in the qy state to make it non-terminal but
loop, and the add a duplication of the input, so H^ can take as an
input
<H^> and then get to the copy of the code of H with <H^> <H^> on the
tape, which is by definition the encoding of the machine H^(<H^>).

Since it is identical code with identical input, but the property of
being a Computation, if H(<H^>.<H^>) will end at H.qn, then H^ will end
at H^.qn (and then halt) and if H ends at H.qy then H^ will get to
H^.qy
(and then loop forever).

Yes, Linz doesn't describe how H is designed to get from H.q0 to
H.qn or
H.qy, and that is intentional, as that is specified totally by the
design of H, and since NOTHING has been assumed about it, no possible H
has been excluded from the reasoning.

Thus, even your simulating halt decider case fits in his model.

Once we know what the provided H will do when given this input, we can
see what the machine that this input represents, and if H said it would
halt, it loops, and if H says it won't halt, it Halts, thus any
answer H
gives will be wrong.

The only other posibilities is that H never gets to either H.qn or
H.qy,
in which case it has also failed to give the right answer.


That is factually incorrect.
H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly transitions to H.qy.

When did you ever claim that H (not H1) ever said that H^(H^) was
halting.

You can't use H1, as H^ is built on H, if you want to use H1, you need
to build the H1^ that calls it to test.

Maybe you still don't know what that line means.


The Linz text does cannot possibly get into sufficient detail to show
how this is not true simply because it is true.


Since your described algorithm for H says that H will declare this input
to be non-halting, you are lying to say that this H goes to the terminal
state qy.

The actual behavior of machine H is determined by the algorithm embedded
in it. That algorithm says that <H^> <H^> represents a non-halting
computation, therefore H will go to H.qn.

Linz says that the H that gives the RIGHT answer for an input that is
Halting will go to H.qy, but your H doesn't go there because it is not
right.

'Give the right answer' is NOT a valid algorithm for a Turing Machine.


When I refer to H1/H I am referring to my C/x86 code.
When I refer to H/Ĥ I am referring to the Peter Linz templates.
You can't seem to keep this straight.




Which means you have something MAJORLY wrong with your argument.

H1 and H in you C/x86 code are two copies of your decider

Linz H is the Correct Halting decider that is what you claim is
equivalent of you H


Not any more. Ever since I created H1 that does not have pathological self-reference (two weeks ago?) retaining H that does have pathological self-reference, my H(P,P) is equivalent to the Linz Ĥ.qx ⟨Ĥ⟩.

My H1(P,P) is equivalent to the Linz H ⟨Ĥ⟩ ⟨Ĥ⟩.
Previosly I had no idea how two different halt deciders would coordinate between themselves so I did not discuss the Linz H ⟨Ĥ⟩ ⟨Ĥ⟩.
There's something horrendously confused about this.

To the extent that I can actually follow your claims given that you keep changing the names of things, here is my current understanding of what you have:

You have created a 'Halt Decider' H.

Alongside that, you also have a 'confounding case' P which you claim is derived from your H in the same way that Linz derives H_Hat from H (It isn't actually, but let's not worry about that for now).

You also have a second Halt Decider H1 which is the same as H except that it 'does not have pathological self-reference'. You've never shown *any* code for this H1, but my assumption is that it is simply a copy of H, but since H1 resides at a distinct machine address from H, if H is called from within H1 it won't be seen as a recursive call.

The problem here is that Linz's proof asserts that for any putative halt decider H, we can construct a new Turing Machine H_Hat which H will be unable to decide.

Your H cannot correctly decide H(P, P). You seem to acknowledge this.

Your H1 according to you *can* correctly decide H1(P, P).

But your P isn't derived from your H1. It is derived from your H. Alongside your H1 there will be a P1 such that H1(P1, P1) will not be correctly decided, so you still aren't overcoming Linz.

Linz doesn't claim that it is impossible for the halting status of H_Hat(H_Hat) to be decided. He claims only that it cannot correctly be decided by H.

Basically (subject to seeing your actual code), you have a machine H which cannot correctly decide whether P(P) halts but which can correctly decide whether P1(P1) halts. You also have a machine H1 which can correctly decide whether P(P) halts but which cannot correctly decide whether P1(P1) halts. So neither of these can possibly count as a universal halt decider since each has a case it cannot decide. Neither your H nor your H1 can decide the corresponding case described by the Linz Proof.

André


By using the H1/H pair we have a universal halt decider.
Whenever they don't provide the same result then one of them is wrong.

int main()
{
   if (H1((u32)P, (u32)P) != H((u32)P, (u32)P))
     OutputString("Pathological self-reference error!");
}


--
Copyright 2021 Pete Olcott

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


Subject: Re: Why do theory of computation problems require pure functions?
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic, sci.math
Date: Sun, 19 Sep 2021 03:32 UTC
References: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
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 22:32:10 -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>
<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>
<L5-dnUtHucSVgNv8nZ2dnUU7-X_NnZ2d@giganews.com>
<12r1J.107151$lC6.16042@fx41.iad>
<caKdncaNf93r3dv8nZ2dnUU7-UfNnZ2d@giganews.com>
<axr1J.55095$jm6.40535@fx07.iad>
<4dqdnW74K8nv1Nv8nZ2dnUU7-d2dnZ2d@giganews.com>
<Sds1J.75975$z%4.33404@fx37.iad>
<0LKdnQW0_vXAz9v8nZ2dnUU7-RHNnZ2d@giganews.com> <si5o18$ca0$1@dont-email.me>
<b8qdnUQWUNeC-Nv8nZ2dnUU7-cvNnZ2d@giganews.com> <si5p69$qpa$1@dont-email.me>
<i6WdnR3uOcyR9Nv8nZ2dnUU7-TGdnZ2d@giganews.com> <si5qpm$srv$1@dont-email.me>
<XbOdnZbe3JqE8tv8nZ2dnUU7-emdnZ2d@giganews.com>
<4lu1J.13876$Im6.4952@fx09.iad>
From: NoO...@NoWhere.com (olcott)
Date: Sat, 18 Sep 2021 22:32:07 -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: <4lu1J.13876$Im6.4952@fx09.iad>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <x8CdnXa9leSnMtv8nZ2dnUU7-RHNnZ2d@giganews.com>
Lines: 101
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-1ClQSXcO/K4b/URuCyLxCoR1TKeIBC6xCqSxYFw0IDp/QZRn3ruYrMSats8evqJH3QaTag4TB3Q3u1x!J2ioeTIM5jttsxVHSNJiEOMsMoLXjpPKO1SmQowm7iNmfWGLpqbo1W7eAz5LPwDvPvwlU52JISJK!2DU=
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: 5241
View all headers
On 9/18/2021 6:09 PM, Richard Damon wrote:
On 9/18/21 6:58 PM, olcott wrote:
On 9/18/2021 5:55 PM, André G. Isaak wrote:
On 2021-09-18 16:32, olcott wrote:
On 9/18/2021 5:28 PM, André G. Isaak wrote:
On 2021-09-18 16:15, olcott wrote:
On 9/18/2021 5:08 PM, André G. Isaak wrote:

Basically (subject to seeing your actual code), you have a machine
H which cannot correctly decide whether P(P) halts but which can
correctly decide whether P1(P1) halts. You also have a machine H1
which can correctly decide whether P(P) halts but which cannot
correctly decide whether P1(P1) halts. So neither of these can
possibly count as a universal halt decider since each has a case
it cannot decide. Neither your H nor your H1 can decide the
corresponding case described by the Linz Proof.

André


By using the H1/H pair we have a universal halt decider.
Whenever they don't provide the same result then one of them is wrong.

And since you have no idea *which* one of them is wrong, how exactly
is it that you have a 'universal halt decider'?

André



I just defeated Rice's theorem, the other details are for another day.

How exactly have you managed to do that?


I already told you. I wish you would pay attention.

int main()
{
   if (H1((u32)P, (u32)P) != H((u32)P, (u32)P))
     OutputString("Pathological self-reference error!");
}



Which itself proves nothing.

What is the precise Semantic Property that you are deciding on.

Also, Rice's theorem requires a Decider to give the answer, so an if in
main isn't the decider that disproves Rice.

Define your property precisely enough that others can verify it.

Define a decider (maybe call it R) that decides that property on a
machine given to it.

My first guess is that you mean R to be:

u32 R(u32 P) {
    return H1(P,P) != H(P,P);
}

but now you have to specify what semantic property of P it is detecting.


As I have been saying since at least 2004:
As I have been saying since at least 2004:
As I have been saying since at least 2004:
As I have been saying since at least 2004:

The input has the exact same error as the Liar Paradox

[Halting Problem Final Conclusion]
comp.theory
Peter Olcott
Sep 5, 2004, 11:21:57 AM

The Liar Paradox can be shown to be nothing more than
a incorrectly formed statement because of its pathological
self-reference. The Halting Problem can only exist because
of this same sort of pathological self-reference.
https://groups.google.com/g/comp.theory/c/RO9Z9eCabeE/m/Ka8-xS2rdEEJ

u32 PSR_Olcott_2004(u32 P)
{
   return H1(P,P) != H(P,P);
}

int main()
{
   Output("Pathological Self-Reference(Olcott 2004) = ",
           PSR_Olcott_2004((u32) P));
}


--
Copyright 2021 Pete Olcott

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


Subject: Re: Why do theory of computation problems require pure functions?[ decidability decider citation ]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic, sci.math
Date: Sun, 19 Sep 2021 11:56 UTC
References: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
Path: i2pn2.org!i2pn.org!paganini.bofh.team!news.dns-netz.com!news.freedyn.net!newsfeed.xs4all.nl!newsfeed9.news.xs4all.nl!tr2.eu1.usenetexpress.com!feeder.usenetexpress.com!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: Sun, 19 Sep 2021 06:56:11 -0500
Subject: Re: Why do theory of computation problems require pure functions?[ decidability decider citation ]
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <a7WdnftR4JAUzNj8nZ2dnUU7-d_NnZ2d@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> <L5-dnUtHucSVgNv8nZ2dnUU7-X_NnZ2d@giganews.com> <12r1J.107151$lC6.16042@fx41.iad> <caKdncaNf93r3dv8nZ2dnUU7-UfNnZ2d@giganews.com> <axr1J.55095$jm6.40535@fx07.iad> <4dqdnW74K8nv1Nv8nZ2dnUU7-d2dnZ2d@giganews.com> <Sds1J.75975$z%4.33404@fx37.iad> <0LKdnQW0_vXAz9v8nZ2dnUU7-RHNnZ2d@giganews.com> <si5o18$ca0$1@dont-email.me> <b8qdnUQWUNeC-Nv8nZ2dnUU7-cvNnZ2d@giganews.com> <si5p69$qpa$1@dont-email.me> <i6WdnR3uOcyR9Nv8nZ2dnUU7-TGdnZ2d@giganews.com> <si5qpm$srv$1@dont-email.me> <XbOdnZbe3JqE8tv8nZ2dnUU7-emdnZ2d@giganews.com> <4lu1J.13876$Im6.4952@fx09.iad> <x8CdnXa9leSnMtv8nZ2dnUU7-RHNnZ2d@giganews.com> <si6d74$tv6$1@dont-email.me> <si6dp3$7u1$1@dont-email.me> <Nt6dnbjHeOVBW9v8nZ2dnUU7-a3NnZ2d@giganews.com> <si6jmq$er3$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
Date: Sun, 19 Sep 2021 06:56:09 -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: <si6jmq$er3$1@dont-email.me>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <LvOdnbExcdfBuNr8nZ2dnUU7-aHNnZ2d@giganews.com>
Lines: 75
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-Dq9qLAJb7zGuvzX8JJSwl4Zcoqi3FVlzwpdhNt30W9cAgoTGEUn8VPi1cj7/gIHCE8XqlHm2eeV9iAw!lkkDvZwWm3ZR38+t8+MLI7KEgb48Y048n0kPbWA8Lsd9yMKqoeXHCJuugqyFEGR/khf/TVzT5/ee!0jA=
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: 4853
View all headers
On 9/19/2021 1:00 AM, André G. Isaak wrote:
On 2021-09-18 23:12, olcott wrote:
On 9/18/2021 11:19 PM, André G. Isaak wrote:
On 2021-09-18 22:10, André G. Isaak wrote:

And note that Rice is talking about properties of Turing Machines (or, more properly, of the language accepted by a TM), not computations.

I realized immediately after hitting 'send' that the above will no doubt confuse you since people have been telling you that Turing Machines can only express computations whereas C/x86 aren't thus constrained.

A computation is a Turing Machine description PLUS an input string.

Rice's theorem is concerned with the Turing Machine's themselves.

The Linz proof shows that you cannot construct a halting decider, i.e. a decider which correctly determines for any given TM + input string pair, whether that pair represents a halting computation.

Rice's theorem, on the other hand, would rule out the construction of something like a Decider Decider, i.e. a TM which takes as its input a TM description and determines whether that TM qualifies as a decider, i.e. is guaranteed to halt on *any* possible input.

André


Bingo! I have said it this same way recently.

No, you have not.


On 9/9/2021 10:25 AM, olcott wrote:
 > It is the case that H(P,P)==0 is correct
 > It is the case that H1((P,P)==1 is correct
 > It is the case the this is inconsistent.
 > It is the case that this inconsistency defines a

 > decidability decider that correctly rejects P on
 > the basis that P has the
 > pathological self-reference(Olcott 2004) error.

 > decidability decider that correctly rejects P on
 > the basis that P has the
 > pathological self-reference(Olcott 2004) error.

 > decidability decider that correctly rejects P on
 > the basis that P has the
 > pathological self-reference(Olcott 2004) error.


// Decidability Decider
u32 PSR_Olcott_2004(u32 P)
{
   return H1(P,P) == H(P,P);
}

And how is the above related to anything I wrote in my original post or in the post clarifying that post to which you are responding? You don't answer the actual question which was asked (i.e. which semantic property do you claim to be able to decide using the above?) nor do you show even the remotest evidence of having even read my post.

André



--
Copyright 2021 Pete Olcott

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


Subject: Re: Why do theory of computation problems require pure functions? [ PSR error]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.lang, sci.logic
Date: Sun, 19 Sep 2021 16:39 UTC
References: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
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: Sun, 19 Sep 2021 11:39:25 -0500
Subject: Re: Why do theory of computation problems require pure functions? [
PSR error]
Newsgroups: comp.theory,comp.ai.philosophy,sci.lang,sci.logic
References: <a7WdnftR4JAUzNj8nZ2dnUU7-d_NnZ2d@giganews.com>
<si531f$q3f$2@dont-email.me> <CtmdnXIC2u_Di9v8nZ2dnUU7-R3NnZ2d@giganews.com>
<si55gs$aa2$1@dont-email.me> <L5-dnUtHucSVgNv8nZ2dnUU7-X_NnZ2d@giganews.com>
<12r1J.107151$lC6.16042@fx41.iad>
<caKdncaNf93r3dv8nZ2dnUU7-UfNnZ2d@giganews.com>
<axr1J.55095$jm6.40535@fx07.iad>
<4dqdnW74K8nv1Nv8nZ2dnUU7-d2dnZ2d@giganews.com>
<Sds1J.75975$z%4.33404@fx37.iad>
<0LKdnQW0_vXAz9v8nZ2dnUU7-RHNnZ2d@giganews.com> <si5o18$ca0$1@dont-email.me>
<b8qdnUQWUNeC-Nv8nZ2dnUU7-cvNnZ2d@giganews.com> <si5p69$qpa$1@dont-email.me>
<i6WdnR3uOcyR9Nv8nZ2dnUU7-TGdnZ2d@giganews.com> <si5qpm$srv$1@dont-email.me>
<XbOdnZbe3JqE8tv8nZ2dnUU7-emdnZ2d@giganews.com>
<4lu1J.13876$Im6.4952@fx09.iad>
<x8CdnXa9leSnMtv8nZ2dnUU7-RHNnZ2d@giganews.com> <si6d74$tv6$1@dont-email.me>
<si6dp3$7u1$1@dont-email.me> <kZadne336bvC19r8nZ2dnUU7-L_NnZ2d@giganews.com>
<si7lli$n28$1@dont-email.me> <ZLidnRFCjJnaxtr8nZ2dnUU7-KXNnZ2d@giganews.com>
<si7ng8$s7c$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
Date: Sun, 19 Sep 2021 11:39:25 -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: <si7ng8$s7c$1@dont-email.me>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <n5GdnTqFUbEg-tr8nZ2dnUU7-c3NnZ2d@giganews.com>
Lines: 110
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-DYIGnZvJXKd83ps36pLIlbCsqAH2pYRjURaePMnKo1OATTNQ7VvnXELOW8aW0sFfh2O7+p00jdloBNB!VchoQlx0457srZcd+jqkzdLh/NCjdI15oiwf2JbFowx5ITDZ2BMluYZQKc10XcHIEnXnUBLUaZd3!Y9g=
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: 6477
View all headers
On 9/19/2021 11:11 AM, André G. Isaak wrote:
On 2021-09-19 09:46, olcott wrote:
On 9/19/2021 10:40 AM, André G. Isaak wrote:
On 2021-09-19 08:34, olcott wrote:
On 9/18/2021 11:19 PM, André G. Isaak wrote:
On 2021-09-18 22:10, André G. Isaak wrote:

And note that Rice is talking about properties of Turing Machines (or, more properly, of the language accepted by a TM), not computations.

I realized immediately after hitting 'send' that the above will no doubt confuse you since people have been telling you that Turing Machines can only express computations whereas C/x86 aren't thus constrained.

A computation is a Turing Machine description PLUS an input string.

Rice's theorem is concerned with the Turing Machine's themselves.

The Linz proof shows that you cannot construct a halting decider, i.e. a decider which correctly determines for any given TM + input string pair, whether that pair represents a halting computation.

Rice's theorem, on the other hand, would rule out the construction of something like a Decider Decider, i.e. a TM which takes as its input a TM description and determines whether that TM qualifies as a decider, i.e. is guaranteed to halt on *any* possible input.

André


Here is where I referred to my code defining a
a decidability decider nine days before you did:

Where did I define or even mention a 'decidability decider'? Above I discussed (but did not define) a DECIDER decider, i.e. a TM which determines whether another TM qualifies as a decider.

On 9/9/2021 10:25 AM, olcott wrote:
 > It is the case that H(P,P)==0 is correct
 > It is the case that H1((P,P)==1 is correct
 > It is the case the this is inconsistent.
 > It is the case that this inconsistency

 > defines a decidability decider that correctly
 > defines a decidability decider that correctly
 > defines a decidability decider that correctly

 > rejects P on the basis that P has the
 > pathological self-reference(Olcott 2004) error.

So what exactly is it that the above is deciding? And how does this relate to Rice? If you want to claim this is somehow related to rice, you need to identify some semantic property that you claim to be able to decide.

André


It is deciding that either H/P or H1/P form the pathological self-reference error(Olcott 2004). As I said in 2004 this is the same error as the Liar Paradox. This means that either H/P or H1/P are not correctly decidable.

The post in which I mentioned a 'decider decider' which you somehow misread as 'decidability decider' was intended to clarify a single sentence from an earlier post which you entirely ignored. Why don't you go back and actually read that earlier post and address the points made therein.

Your ill-defined notion of a 'pathological self-reference error' doesn't appear to be a property of a Turing Machine, which is what Rice's theorem is concerned with. To the extent that it is a property at all, it appears to be a property of specific computations, so this has absolutely no relevance to Rice.

André


It is the property of H(P,P).

u32 PSR_Olcott_2004(u32 P)
{
   return H1(P,P) != H(P,P);
}

Decides that H(P,P) cannot correctly decide the halt status of its input, thus a semantic property of H relative to P.

The Liar Paradox works this same way.
"This sentence is not true."
When it refers to itself it has the pathological self-reference error(Olcott 2004).

This is the same as H(P,P) where the input to H refers to H.

When we transform the Liar Paradox so that it does not refer to itself

This sentence is not true: "2 + 3 = 7" then the pathological self-reference error(Olcott 2004) is eliminated.

The same thing occurs with H1(P,P).


--
Copyright 2021 Pete Olcott

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


Subject: Re: Why do theory of computation problems require pure functions? [ PSR error]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic, sci.math
Date: Sun, 19 Sep 2021 17:07 UTC
References: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
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: Sun, 19 Sep 2021 12:07:25 -0500
Subject: Re: Why do theory of computation problems require pure functions? [
PSR error]
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <a7WdnftR4JAUzNj8nZ2dnUU7-d_NnZ2d@giganews.com>
<si55gs$aa2$1@dont-email.me> <L5-dnUtHucSVgNv8nZ2dnUU7-X_NnZ2d@giganews.com>
<12r1J.107151$lC6.16042@fx41.iad>
<caKdncaNf93r3dv8nZ2dnUU7-UfNnZ2d@giganews.com>
<axr1J.55095$jm6.40535@fx07.iad>
<4dqdnW74K8nv1Nv8nZ2dnUU7-d2dnZ2d@giganews.com>
<Sds1J.75975$z%4.33404@fx37.iad>
<0LKdnQW0_vXAz9v8nZ2dnUU7-RHNnZ2d@giganews.com> <si5o18$ca0$1@dont-email.me>
<b8qdnUQWUNeC-Nv8nZ2dnUU7-cvNnZ2d@giganews.com> <si5p69$qpa$1@dont-email.me>
<i6WdnR3uOcyR9Nv8nZ2dnUU7-TGdnZ2d@giganews.com> <si5qpm$srv$1@dont-email.me>
<XbOdnZbe3JqE8tv8nZ2dnUU7-emdnZ2d@giganews.com>
<4lu1J.13876$Im6.4952@fx09.iad>
<x8CdnXa9leSnMtv8nZ2dnUU7-RHNnZ2d@giganews.com> <si6d74$tv6$1@dont-email.me>
<si6dp3$7u1$1@dont-email.me> <kZadne336bvC19r8nZ2dnUU7-L_NnZ2d@giganews.com>
<si7lli$n28$1@dont-email.me> <ZLidnRFCjJnaxtr8nZ2dnUU7-KXNnZ2d@giganews.com>
<si7ng8$s7c$1@dont-email.me> <n5GdnTqFUbEg-tr8nZ2dnUU7-c3NnZ2d@giganews.com>
<si7q37$gbh$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
Date: Sun, 19 Sep 2021 12:07:25 -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: <si7q37$gbh$1@dont-email.me>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <BK6dnbrUf-_Q89r8nZ2dnUU7-YnNnZ2d@giganews.com>
Lines: 133
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-0V3wKIPlDAY/LV3SpqUyPBYaTU56qoylCuiEtxAQZVVjzTisExP5D9y1tmwNhWObOAt0LiJTrQYyY7T!+a9Se/D6KwSiXG9gh0cIPzO6OMXfU+8LPfwZBqP2sEMVE7Dy67JEvDyYGgAECY3/lyko4m7V1PDw!szE=
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: 7446
View all headers
On 9/19/2021 11:56 AM, André G. Isaak wrote:
On 2021-09-19 10:39, olcott wrote:
On 9/19/2021 11:11 AM, André G. Isaak wrote:
On 2021-09-19 09:46, olcott wrote:
On 9/19/2021 10:40 AM, André G. Isaak wrote:
On 2021-09-19 08:34, olcott wrote:
On 9/18/2021 11:19 PM, André G. Isaak wrote:
On 2021-09-18 22:10, André G. Isaak wrote:

And note that Rice is talking about properties of Turing Machines (or, more properly, of the language accepted by a TM), not computations.

I realized immediately after hitting 'send' that the above will no doubt confuse you since people have been telling you that Turing Machines can only express computations whereas C/x86 aren't thus constrained.

A computation is a Turing Machine description PLUS an input string.

Rice's theorem is concerned with the Turing Machine's themselves.

The Linz proof shows that you cannot construct a halting decider, i.e. a decider which correctly determines for any given TM + input string pair, whether that pair represents a halting computation.

Rice's theorem, on the other hand, would rule out the construction of something like a Decider Decider, i.e. a TM which takes as its input a TM description and determines whether that TM qualifies as a decider, i.e. is guaranteed to halt on *any* possible input.

André


Here is where I referred to my code defining a
a decidability decider nine days before you did:

Where did I define or even mention a 'decidability decider'? Above I discussed (but did not define) a DECIDER decider, i.e. a TM which determines whether another TM qualifies as a decider.

On 9/9/2021 10:25 AM, olcott wrote:
 > It is the case that H(P,P)==0 is correct
 > It is the case that H1((P,P)==1 is correct
 > It is the case the this is inconsistent.
 > It is the case that this inconsistency

 > defines a decidability decider that correctly
 > defines a decidability decider that correctly
 > defines a decidability decider that correctly

 > rejects P on the basis that P has the
 > pathological self-reference(Olcott 2004) error.

So what exactly is it that the above is deciding? And how does this relate to Rice? If you want to claim this is somehow related to rice, you need to identify some semantic property that you claim to be able to decide.

André


It is deciding that either H/P or H1/P form the pathological self-reference error(Olcott 2004). As I said in 2004 this is the same error as the Liar Paradox. This means that either H/P or H1/P are not correctly decidable.

The post in which I mentioned a 'decider decider' which you somehow misread as 'decidability decider' was intended to clarify a single sentence from an earlier post which you entirely ignored. Why don't you go back and actually read that earlier post and address the points made therein.

Your ill-defined notion of a 'pathological self-reference error' doesn't appear to be a property of a Turing Machine, which is what Rice's theorem is concerned with. To the extent that it is a property at all, it appears to be a property of specific computations, so this has absolutely no relevance to Rice.

André


It is the property of H(P,P).

Right, which means this is entirely irrelevant to Rice's theorem.


Many historical posts in comp.theory say otherwise.
If a function can be provided that correctly decides that a specific TM cannot correctly decide a specific input pair (according to many historical posts on comp.theory) this does refute Rice's theorem.

u32 PSR_Olcott_2004(u32 P)
{
   return H1(P,P) != H(P,P);
}

Decides that H(P,P) cannot correctly decide the halt status of its input,


No, it does not. It decides that the results of H1(P, P) doesn't match the results of H(P, P). It 'decides' that one of these is correct and the other is not but it cannot tell you which one, which means it can't decide whether H(P, P) can correctly decide the halt status of its input.


I simply have not gotten to that part yet.

thus a semantic property of H relative to P.

That's not a property (semantic or otherwise) of *either* P or H.

The Liar Paradox works this same way.

The liar's paradox is completely irrelevant to Linz.

André


The pathological self-reference error (Olcott 2004) is specifically relevant to:
(a) The Halting Theorem
(b) The 1931 Incompleteness Theorem
(c) The Tarski undefinability theorem
(d) The Liar Paradox (upon which (c) is based).

--
Copyright 2021 Pete Olcott

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


Subject: Re: Why do theory of computation problems require pure functions? [ PSR error]
From: Jeff Barnett
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic, sci.math
Organization: A noiseless patient Spider
Date: Sun, 19 Sep 2021 17:36 UTC
References: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: jbb...@notatt.com (Jeff Barnett)
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
Subject: Re: Why do theory of computation problems require pure functions? [
PSR error]
Date: Sun, 19 Sep 2021 11:36:10 -0600
Organization: A noiseless patient Spider
Lines: 29
Message-ID: <si7seg$uq7$1@dont-email.me>
References: <a7WdnftR4JAUzNj8nZ2dnUU7-d_NnZ2d@giganews.com>
<12r1J.107151$lC6.16042@fx41.iad>
<caKdncaNf93r3dv8nZ2dnUU7-UfNnZ2d@giganews.com>
<axr1J.55095$jm6.40535@fx07.iad>
<4dqdnW74K8nv1Nv8nZ2dnUU7-d2dnZ2d@giganews.com>
<Sds1J.75975$z%4.33404@fx37.iad>
<0LKdnQW0_vXAz9v8nZ2dnUU7-RHNnZ2d@giganews.com> <si5o18$ca0$1@dont-email.me>
<b8qdnUQWUNeC-Nv8nZ2dnUU7-cvNnZ2d@giganews.com> <si5p69$qpa$1@dont-email.me>
<i6WdnR3uOcyR9Nv8nZ2dnUU7-TGdnZ2d@giganews.com> <si5qpm$srv$1@dont-email.me>
<XbOdnZbe3JqE8tv8nZ2dnUU7-emdnZ2d@giganews.com>
<4lu1J.13876$Im6.4952@fx09.iad>
<x8CdnXa9leSnMtv8nZ2dnUU7-RHNnZ2d@giganews.com> <si6d74$tv6$1@dont-email.me>
<si6dp3$7u1$1@dont-email.me> <kZadne336bvC19r8nZ2dnUU7-L_NnZ2d@giganews.com>
<si7lli$n28$1@dont-email.me> <ZLidnRFCjJnaxtr8nZ2dnUU7-KXNnZ2d@giganews.com>
<si7ng8$s7c$1@dont-email.me> <n5GdnTqFUbEg-tr8nZ2dnUU7-c3NnZ2d@giganews.com>
<si7q37$gbh$1@dont-email.me> <BK6dnbrUf-_Q89r8nZ2dnUU7-YnNnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 7bit
Injection-Date: Sun, 19 Sep 2021 17:36:16 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="36535cffe0e891c62bf9d04e14e38b58";
logging-data="31559"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX19886dQanyqJ7CxPoqGFkXFXfVcwhRCha8="
User-Agent: Mozilla/5.0 (Windows NT 6.1; Win64; x64; rv:78.0) Gecko/20100101
Thunderbird/78.14.0
Cancel-Lock: sha1:aeUcxXADmVJqXdBkTr7jciypiOY=
In-Reply-To: <BK6dnbrUf-_Q89r8nZ2dnUU7-YnNnZ2d@giganews.com>
Content-Language: en-US
View all headers
On 9/19/2021 11:07 AM, olcott wrote:
The pathological self-reference error (Olcott 2004) is specifically relevant to:
(a) The Halting Theorem
(b) The 1931 Incompleteness Theorem
(c) The Tarski undefinability theorem
(d) The Liar Paradox (upon which (c) is based).

Nothing you have done in the past two decades seems to be relevant to anything. Seems? Just being polite. Actually, why bother: Nothing you have done in the past two decades is relevant to anything. How long has your illness made your brain dysfunctional? Friendly reminders: don't get ahead of yourself; take your meds, all of them.

There are only two paths to long lasting fame for yourself: The first is to write the USENET version of "The Trisectors" by Underwood Duddley. The second is to collect two decades of your idiotic newsgroup threads and turn them into a classic entitled "How to Go Directly from Stark Personal Depression to Being a World Class Self-Deluded Troll Without Missing a Meal."

The latter suggestion would be enhanced if you could put your publication in an academic series with "How To Go Directly Into Solo Law Practice Without Missing a Meal" by Gerald M. Singer (an LA lawyer). Fame and notoriety all based on your original works awaits you. And now we see how all those clever copyright annotations are going to pay off with big bucks.
--
Jeff Barnett


Subject: Re: Why do theory of computation problems require pure functions? [ PSR error]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic, sci.math
Date: Sun, 19 Sep 2021 17:54 UTC
References: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sun, 19 Sep 2021 12:54:56 -0500
Subject: Re: Why do theory of computation problems require pure functions? [
PSR error]
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <a7WdnftR4JAUzNj8nZ2dnUU7-d_NnZ2d@giganews.com>
<12r1J.107151$lC6.16042@fx41.iad>
<caKdncaNf93r3dv8nZ2dnUU7-UfNnZ2d@giganews.com>
<axr1J.55095$jm6.40535@fx07.iad>
<4dqdnW74K8nv1Nv8nZ2dnUU7-d2dnZ2d@giganews.com>
<Sds1J.75975$z%4.33404@fx37.iad>
<0LKdnQW0_vXAz9v8nZ2dnUU7-RHNnZ2d@giganews.com> <si5o18$ca0$1@dont-email.me>
<b8qdnUQWUNeC-Nv8nZ2dnUU7-cvNnZ2d@giganews.com> <si5p69$qpa$1@dont-email.me>
<i6WdnR3uOcyR9Nv8nZ2dnUU7-TGdnZ2d@giganews.com> <si5qpm$srv$1@dont-email.me>
<XbOdnZbe3JqE8tv8nZ2dnUU7-emdnZ2d@giganews.com>
<4lu1J.13876$Im6.4952@fx09.iad>
<x8CdnXa9leSnMtv8nZ2dnUU7-RHNnZ2d@giganews.com> <si6d74$tv6$1@dont-email.me>
<si6dp3$7u1$1@dont-email.me> <kZadne336bvC19r8nZ2dnUU7-L_NnZ2d@giganews.com>
<si7lli$n28$1@dont-email.me> <ZLidnRFCjJnaxtr8nZ2dnUU7-KXNnZ2d@giganews.com>
<si7ng8$s7c$1@dont-email.me> <n5GdnTqFUbEg-tr8nZ2dnUU7-c3NnZ2d@giganews.com>
<si7q37$gbh$1@dont-email.me> <BK6dnbrUf-_Q89r8nZ2dnUU7-YnNnZ2d@giganews.com>
<si7rq1$i84$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
Date: Sun, 19 Sep 2021 12:54:55 -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: <si7rq1$i84$1@dont-email.me>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <q5KdnWcPfprt5Nr8nZ2dnUU7-TPNnZ2d@giganews.com>
Lines: 190
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-uMq4aiLs5bLJXCToFnLKCZOGKVxLr95ZZPMGC5BAcstxARW3b4tYGG9lWG/gZ4UMZRkmHCjt50utwDh!FZo7ObZtI1fx23TtAwXfC3r6hHDUnhtVFBkccSxl5dXKG67VE627o/1+itt6hQOFvx/ABKXC6z9n!scE=
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: 9830
View all headers
On 9/19/2021 12:25 PM, André G. Isaak wrote:
On 2021-09-19 11:07, olcott wrote:
On 9/19/2021 11:56 AM, André G. Isaak wrote:
On 2021-09-19 10:39, olcott wrote:
On 9/19/2021 11:11 AM, André G. Isaak wrote:
On 2021-09-19 09:46, olcott wrote:
On 9/19/2021 10:40 AM, André G. Isaak wrote:
On 2021-09-19 08:34, olcott wrote:
On 9/18/2021 11:19 PM, André G. Isaak wrote:
On 2021-09-18 22:10, André G. Isaak wrote:

And note that Rice is talking about properties of Turing Machines (or, more properly, of the language accepted by a TM), not computations.

I realized immediately after hitting 'send' that the above will no doubt confuse you since people have been telling you that Turing Machines can only express computations whereas C/x86 aren't thus constrained.

A computation is a Turing Machine description PLUS an input string.

Rice's theorem is concerned with the Turing Machine's themselves.

The Linz proof shows that you cannot construct a halting decider, i.e. a decider which correctly determines for any given TM + input string pair, whether that pair represents a halting computation.

Rice's theorem, on the other hand, would rule out the construction of something like a Decider Decider, i.e. a TM which takes as its input a TM description and determines whether that TM qualifies as a decider, i.e. is guaranteed to halt on *any* possible input.

André


Here is where I referred to my code defining a
a decidability decider nine days before you did:

Where did I define or even mention a 'decidability decider'? Above I discussed (but did not define) a DECIDER decider, i.e. a TM which determines whether another TM qualifies as a decider.

On 9/9/2021 10:25 AM, olcott wrote:
 > It is the case that H(P,P)==0 is correct
 > It is the case that H1((P,P)==1 is correct
 > It is the case the this is inconsistent.
 > It is the case that this inconsistency

 > defines a decidability decider that correctly
 > defines a decidability decider that correctly
 > defines a decidability decider that correctly

 > rejects P on the basis that P has the
 > pathological self-reference(Olcott 2004) error.

So what exactly is it that the above is deciding? And how does this relate to Rice? If you want to claim this is somehow related to rice, you need to identify some semantic property that you claim to be able to decide.

André


It is deciding that either H/P or H1/P form the pathological self-reference error(Olcott 2004). As I said in 2004 this is the same error as the Liar Paradox. This means that either H/P or H1/P are not correctly decidable.

The post in which I mentioned a 'decider decider' which you somehow misread as 'decidability decider' was intended to clarify a single sentence from an earlier post which you entirely ignored. Why don't you go back and actually read that earlier post and address the points made therein.

Your ill-defined notion of a 'pathological self-reference error' doesn't appear to be a property of a Turing Machine, which is what Rice's theorem is concerned with. To the extent that it is a property at all, it appears to be a property of specific computations, so this has absolutely no relevance to Rice.

André


It is the property of H(P,P).

Right, which means this is entirely irrelevant to Rice's theorem.


Many historical posts in comp.theory say otherwise.
If a function can be provided that correctly decides that a specific TM cannot correctly decide a specific input pair (according to many historical posts on comp.theory) this does refute Rice's theorem.

So what is the semantic property *of P* that you claim your PSR_Olcott_2004 is capable of identifying?

You can't claim that there is anything 'erroneous' about P. There isn't.

The fact that you run into a problem when you pass a description of P to some *other* TM is not an indicator that there is something wrong with P. That's like saying that the expression 40 + 50 is 'erroneous' because I can't pass it as an argument to tangent().

u32 PSR_Olcott_2004(u32 P)
{
   return H1(P,P) != H(P,P);
}

Decides that H(P,P) cannot correctly decide the halt status of its input,


No, it does not. It decides that the results of H1(P, P) doesn't match the results of H(P, P). It 'decides' that one of these is correct and the other is not but it cannot tell you which one, which means it can't decide whether H(P, P) can correctly decide the halt status of its input.


I simply have not gotten to that part yet.

And yet you claimed to be able to 'decide' that H(P, P) cannot correctly decide the halt status of its input. Until you actually 'get to that part' you have no business making such a claim.


Odd man out:
When H1(P,P) != H(P,P) we test
   HX(P,P) != H1(P,P)
   HX(P,P) != H(P,P)

The one that HX(P,P) agrees with is the correct one.

thus a semantic property of H relative to P.

That's not a property (semantic or otherwise) of *either* P or H.

The Liar Paradox works this same way.

The liar's paradox is completely irrelevant to Linz.

André


The pathological self-reference error (Olcott 2004) is specifically relevant to:
(a) The Halting Theorem
(b) The 1931 Incompleteness Theorem
(c) The Tarski undefinability theorem
(d) The Liar Paradox (upon which (c) is based).

So why don't you:

(a) provide a proper definition of "pathological self-reference error"
     That means a definition which will allow one to unambiguosly determine whether an arbitrary expression/entity has this error.

I just provided a reference to function that correctly decide this.
As long as my "pure function of its inputs" becomes fully validated
I will be able to provide the actual source-code that makes this decision.

(b) explain in what sense an "error" is a property.
(c) demonstrate that whatever property you are referring to is a *semantic* property.

André


The pathological self reference error is when an
(a) Input P to a halt decider   // halting theorem
has self-reference such that the Boolean value of H(P,P)
cannot be correctly determined by H.

(b) An expression of natural language // liar paradox
has self-reference such that the Boolean value this expression cannot be correctly determined.

(c) An expression of formal language // incompleteness / undefinability.
has self-reference such that the Boolean value this expression cannot be correctly determined within the same formal system.

--
Copyright 2021 Pete Olcott

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


Subject: Re: Why do theory of computation problems require pure functions? [ PSR error]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic, sci.math
Date: Sun, 19 Sep 2021 18:33 UTC
References: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
Path: i2pn2.org!i2pn.org!aioe.org!feeder1.feed.usenet.farm!feed.usenet.farm!tr2.eu1.usenetexpress.com!feeder.usenetexpress.com!tr1.iad1.usenetexpress.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sun, 19 Sep 2021 13:33:42 -0500
Subject: Re: Why do theory of computation problems require pure functions? [ PSR error]
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <a7WdnftR4JAUzNj8nZ2dnUU7-d_NnZ2d@giganews.com> <axr1J.55095$jm6.40535@fx07.iad> <4dqdnW74K8nv1Nv8nZ2dnUU7-d2dnZ2d@giganews.com> <Sds1J.75975$z%4.33404@fx37.iad> <0LKdnQW0_vXAz9v8nZ2dnUU7-RHNnZ2d@giganews.com> <si5o18$ca0$1@dont-email.me> <b8qdnUQWUNeC-Nv8nZ2dnUU7-cvNnZ2d@giganews.com> <si5p69$qpa$1@dont-email.me> <i6WdnR3uOcyR9Nv8nZ2dnUU7-TGdnZ2d@giganews.com> <si5qpm$srv$1@dont-email.me> <XbOdnZbe3JqE8tv8nZ2dnUU7-emdnZ2d@giganews.com> <4lu1J.13876$Im6.4952@fx09.iad> <x8CdnXa9leSnMtv8nZ2dnUU7-RHNnZ2d@giganews.com> <si6d74$tv6$1@dont-email.me> <si6dp3$7u1$1@dont-email.me> <kZadne336bvC19r8nZ2dnUU7-L_NnZ2d@giganews.com> <si7lli$n28$1@dont-email.me> <ZLidnRFCjJnaxtr8nZ2dnUU7-KXNnZ2d@giganews.com> <si7ng8$s7c$1@dont-email.me> <n5GdnTqFUbEg-tr8nZ2dnUU7-c3NnZ2d@giganews.com> <si7q37$gbh$1@dont-email.me> <BK6dnbrUf-_Q89r8nZ2dnUU7-YnNnZ2d@giganews.com> <si7rq1$i84$1@dont-email.me> <q5KdnWcPfprt5Nr8nZ2dnUU7-TPNnZ2d@giganews.com> <si7v9e$o2e$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
Date: Sun, 19 Sep 2021 13:33:41 -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: <si7v9e$o2e$1@dont-email.me>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <Mpqdnd411tcbH9r8nZ2dnUU7-NnNnZ2d@giganews.com>
Lines: 231
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-gKZdGQPhMuNZsN6mRQi14Vcz6XmdFZxlGgEm0OUMar+CP9p+pVF0J1cHS7tRIqKfCtMWJoeEeY1KHAe!8Nb2IcqLQ2lTPYhVzv32yyAxR3h0Rx35CHs/3VRbp6KZ5F3YaB0QJlJnxsqxxxVLHlnVBrAdxrnI!CX0=
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: 11980
View all headers
On 9/19/2021 1:24 PM, André G. Isaak wrote:
On 2021-09-19 11:54, olcott wrote:
On 9/19/2021 12:25 PM, André G. Isaak wrote:
On 2021-09-19 11:07, olcott wrote:
On 9/19/2021 11:56 AM, André G. Isaak wrote:
On 2021-09-19 10:39, olcott wrote:
On 9/19/2021 11:11 AM, André G. Isaak wrote:
On 2021-09-19 09:46, olcott wrote:
On 9/19/2021 10:40 AM, André G. Isaak wrote:
On 2021-09-19 08:34, olcott wrote:
On 9/18/2021 11:19 PM, André G. Isaak wrote:
On 2021-09-18 22:10, André G. Isaak wrote:

And note that Rice is talking about properties of Turing Machines (or, more properly, of the language accepted by a TM), not computations.

I realized immediately after hitting 'send' that the above will no doubt confuse you since people have been telling you that Turing Machines can only express computations whereas C/x86 aren't thus constrained.

A computation is a Turing Machine description PLUS an input string.

Rice's theorem is concerned with the Turing Machine's themselves.

The Linz proof shows that you cannot construct a halting decider, i.e. a decider which correctly determines for any given TM + input string pair, whether that pair represents a halting computation.

Rice's theorem, on the other hand, would rule out the construction of something like a Decider Decider, i.e. a TM which takes as its input a TM description and determines whether that TM qualifies as a decider, i.e. is guaranteed to halt on *any* possible input.

André


Here is where I referred to my code defining a
a decidability decider nine days before you did:

Where did I define or even mention a 'decidability decider'? Above I discussed (but did not define) a DECIDER decider, i.e. a TM which determines whether another TM qualifies as a decider.

On 9/9/2021 10:25 AM, olcott wrote:
 > It is the case that H(P,P)==0 is correct
 > It is the case that H1((P,P)==1 is correct
 > It is the case the this is inconsistent.
 > It is the case that this inconsistency

 > defines a decidability decider that correctly
 > defines a decidability decider that correctly
 > defines a decidability decider that correctly

 > rejects P on the basis that P has the
 > pathological self-reference(Olcott 2004) error.

So what exactly is it that the above is deciding? And how does this relate to Rice? If you want to claim this is somehow related to rice, you need to identify some semantic property that you claim to be able to decide.

André


It is deciding that either H/P or H1/P form the pathological self-reference error(Olcott 2004). As I said in 2004 this is the same error as the Liar Paradox. This means that either H/P or H1/P are not correctly decidable.

The post in which I mentioned a 'decider decider' which you somehow misread as 'decidability decider' was intended to clarify a single sentence from an earlier post which you entirely ignored. Why don't you go back and actually read that earlier post and address the points made therein.

Your ill-defined notion of a 'pathological self-reference error' doesn't appear to be a property of a Turing Machine, which is what Rice's theorem is concerned with. To the extent that it is a property at all, it appears to be a property of specific computations, so this has absolutely no relevance to Rice.

André


It is the property of H(P,P).

Right, which means this is entirely irrelevant to Rice's theorem.


Many historical posts in comp.theory say otherwise.
If a function can be provided that correctly decides that a specific TM cannot correctly decide a specific input pair (according to many historical posts on comp.theory) this does refute Rice's theorem.

So what is the semantic property *of P* that you claim your PSR_Olcott_2004 is capable of identifying?

You can't claim that there is anything 'erroneous' about P. There isn't.

The fact that you run into a problem when you pass a description of P to some *other* TM is not an indicator that there is something wrong with P. That's like saying that the expression 40 + 50 is 'erroneous' because I can't pass it as an argument to tangent().

u32 PSR_Olcott_2004(u32 P)
{
   return H1(P,P) != H(P,P);
}

Decides that H(P,P) cannot correctly decide the halt status of its input,


No, it does not. It decides that the results of H1(P, P) doesn't match the results of H(P, P). It 'decides' that one of these is correct and the other is not but it cannot tell you which one, which means it can't decide whether H(P, P) can correctly decide the halt status of its input.


I simply have not gotten to that part yet.

And yet you claimed to be able to 'decide' that H(P, P) cannot correctly decide the halt status of its input. Until you actually 'get to that part' you have no business making such a claim.


Odd man out:
When H1(P,P) != H(P,P) we test
   HX(P,P) != H1(P,P)
   HX(P,P) != H(P,P)

The one that HX(P,P) agrees with is the correct one.

There are a potentially infinite number of Hns. Your 'decider' only qualifies as a decider if it works for *every* one of them. Your 'odd man out strategy' only works if the case you are testing happens to be among the three which are included in your test function.


The halting theorem is based on an artificially contrived example that would never actually occur in actual practice. In actual practice we would only actually need H.

The odd-man-out system does correctly decide an input that was artificially contrived to specifically have the pathological self-reference error (Olcott 2004) for either H or H1. All of the rest of the cases are simply correctly decided by either H or H1.

thus a semantic property of H relative to P.

That's not a property (semantic or otherwise) of *either* P or H.

The Liar Paradox works this same way.

The liar's paradox is completely irrelevant to Linz.

André


The pathological self-reference error (Olcott 2004) is specifically relevant to:
(a) The Halting Theorem
(b) The 1931 Incompleteness Theorem
(c) The Tarski undefinability theorem
(d) The Liar Paradox (upon which (c) is based).

So why don't you:

(a) provide a proper definition of "pathological self-reference error"
     That means a definition which will allow one to unambiguosly determine whether an arbitrary expression/entity has this error.

I just provided a reference to function that correctly decide this.

No. You provided an ad hoc function which decides it for a *single* case. That's not the same thing as a function which correctly decides it.


This will come later when my "pure function of its inputs" has been totally validated.

It is a well-established fact that you cannot trisect an arbitrary angle using only a compass and straightedge. I can show you how to trisect a 90° angle using a compass and straightedge, but this doesn't refute the claim. Only a solution which works for *any* angle would refute the claim.

As long as my "pure function of its inputs" becomes fully validated
I will be able to provide the actual source-code that makes this decision.

(b) explain in what sense an "error" is a property.
(c) demonstrate that whatever property you are referring to is a *semantic* property.

André


The pathological self reference error is when an
(a) Input P to a halt decider   // halting theorem
has self-reference such that the Boolean value of H(P,P)
cannot be correctly determined by H.
(b) An expression of natural language // liar paradox
has self-reference such that the Boolean value this expression cannot be correctly determined.

(c) An expression of formal language // incompleteness / undefinability.
has self-reference such that the Boolean value this expression cannot be correctly determined within the same formal system.

None of those constitute definitions. Nor do they identify properties. And if you want to claim that PSR is an actual thing, you need a single definition. And, as has been pointed out to you numerous times, neither the halting problem proofs nor the incompleteness theorem involve self-reference at all. This is just your imaginary bugaboo.

André



--
Copyright 2021 Pete Olcott

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


Subject: Re: Why do theory of computation problems require pure functions?
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic, sci.math
Date: Tue, 21 Sep 2021 02:35 UTC
References: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
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: Mon, 20 Sep 2021 21:35:06 -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>
<caKdncaNf93r3dv8nZ2dnUU7-UfNnZ2d@giganews.com>
<axr1J.55095$jm6.40535@fx07.iad>
<4dqdnW74K8nv1Nv8nZ2dnUU7-d2dnZ2d@giganews.com>
<Sds1J.75975$z%4.33404@fx37.iad>
<0LKdnQW0_vXAz9v8nZ2dnUU7-RHNnZ2d@giganews.com> <si5o18$ca0$1@dont-email.me>
<b8qdnUQWUNeC-Nv8nZ2dnUU7-cvNnZ2d@giganews.com> <si5p69$qpa$1@dont-email.me>
<i6WdnR3uOcyR9Nv8nZ2dnUU7-TGdnZ2d@giganews.com> <si5qpm$srv$1@dont-email.me>
<b885b582-6153-4184-8dad-aed5dfc83cecn@googlegroups.com>
<87bl4o9rfk.fsf@bsb.me.uk>
<9f3d89f7-6040-4d9f-96e8-4fb18bf6985fn@googlegroups.com>
<877dfc891e.fsf@bsb.me.uk>
<95d4a88f-8fbe-4151-a6bf-c83103d77f1bn@googlegroups.com>
<GdSdnbDQ5umIf9r8nZ2dnUU7-UednZ2d@giganews.com> <875yuv7ei8.fsf@bsb.me.uk>
<i96dnQP238RsBdX8nZ2dnUU7-XPNnZ2d@giganews.com> <87fsty6gxi.fsf@bsb.me.uk>
<VtmdnSy6oZ3Jh9T8nZ2dnUU7-XvNnZ2d@giganews.com>
<qza2J.10311$mg5.1807@fx26.iad>
<Aeednb1MrM3jq9T8nZ2dnUU7-YnNnZ2d@giganews.com>
<Xkb2J.32106$6U3.5490@fx43.iad>
From: NoO...@NoWhere.com (olcott)
Date: Mon, 20 Sep 2021 21:35:05 -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: <Xkb2J.32106$6U3.5490@fx43.iad>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <K7Cdnaz-Go1H2dT8nZ2dnUU7-d_NnZ2d@giganews.com>
Lines: 91
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-0983dxyB4yh48xupsR68KDCTXuamJHnelwN7JK7aPoVRNIbPlr9uRxhXfbKSh/RBqKnuZnYgvnLNeDf!Ir4qzsmUoRgrpkpKCUrjWutMbXnmkXUetT4KDs41YRAWRpWLVwSRxf9kAVNILaza0TZQjB5nkRqW!ULA=
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: 5467
View all headers
On 9/20/2021 9:21 PM, Richard Damon wrote:
On 9/20/21 9:33 PM, olcott wrote:
On 9/20/2021 8:28 PM, Richard Damon wrote:
On 9/20/21 7:33 PM, olcott wrote:
On 9/20/2021 5:06 PM, Ben Bacarisse wrote:
olcott <NoOne@NoWhere.com> writes:

On 9/20/2021 5:00 AM, Ben Bacarisse wrote:
olcott <NoOne@NoWhere.com> writes:

The two machines are already fully operational.
H1 is merely a copy of H.
It's deceptive to call your secret C functions "machines".  It
hints at
the formality a clarity of Turing machines, but a TM that is a
copy of
another will have exactly the same transfer function (i.e. it will
never
compute a different result).

Unless one of them has a pathological self-reference relationship with
its input and the other one does not.

No.  I stated a fact (about TMs) that has no exceptions.  Your secret C
code is another matter, of course.  It's just the deception of calling
your code a "machine" that I was objecting to.  It gives your hidden
code an air of formality that it lacks.


This is easily proven in a way that you are incapable of understanding.

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

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

Line 1 of main() specifies a different computation than line 2 of main()
even though the source code of H1 is a copy of H.


Right, and since it is a DIFFERENT computation, it doesn't count that it
can decide P.

It is only the computation that P (really H^) is built on that matters.

Since H and H1 are different computaitons, H1 doesn't count.


They are only different because of the pathological self reference
(self-contradiction) error. All inputs not having this error relative to
their halt decider derive identical results for both H and H1.


There is NO 'pathological self reference error' for Turing machines,
because they CAN'T self reference, only provide copies.


Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ halts, and

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt

Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ does specify infinitely nested simulation to every simulating halt decider: Ĥ.qx

Ĥ does have its own machine description as its input so
IT IS SELF-REFERENCE

H ⟨Ĥ⟩ ⟨Ĥ⟩ does not specify infinitely nested simulation to any simulating halt decider: H

H does not have its own machine description as its input so
IT IS NOT SELF-REFERENCE

It doesn't matter what this difference is called, it can even be called "late for dinner". That this difference exists and causes the behavior to vary is what needs to be known.

--
Copyright 2021 Pete Olcott

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


Subject: Re: Why do theory of computation problems require pure functions?
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic, sci.math
Date: Tue, 21 Sep 2021 03:07 UTC
References: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
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: Mon, 20 Sep 2021 22:07:02 -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>
<0LKdnQW0_vXAz9v8nZ2dnUU7-RHNnZ2d@giganews.com> <si5o18$ca0$1@dont-email.me>
<b8qdnUQWUNeC-Nv8nZ2dnUU7-cvNnZ2d@giganews.com> <si5p69$qpa$1@dont-email.me>
<i6WdnR3uOcyR9Nv8nZ2dnUU7-TGdnZ2d@giganews.com> <si5qpm$srv$1@dont-email.me>
<b885b582-6153-4184-8dad-aed5dfc83cecn@googlegroups.com>
<87bl4o9rfk.fsf@bsb.me.uk>
<9f3d89f7-6040-4d9f-96e8-4fb18bf6985fn@googlegroups.com>
<877dfc891e.fsf@bsb.me.uk>
<95d4a88f-8fbe-4151-a6bf-c83103d77f1bn@googlegroups.com>
<GdSdnbDQ5umIf9r8nZ2dnUU7-UednZ2d@giganews.com> <875yuv7ei8.fsf@bsb.me.uk>
<i96dnQP238RsBdX8nZ2dnUU7-XPNnZ2d@giganews.com> <87fsty6gxi.fsf@bsb.me.uk>
<VtmdnSy6oZ3Jh9T8nZ2dnUU7-XvNnZ2d@giganews.com>
<qza2J.10311$mg5.1807@fx26.iad>
<Aeednb1MrM3jq9T8nZ2dnUU7-YnNnZ2d@giganews.com>
<Xkb2J.32106$6U3.5490@fx43.iad>
<K7Cdnaz-Go1H2dT8nZ2dnUU7-d_NnZ2d@giganews.com> <87r1di3auk.fsf@bsb.me.uk>
From: NoO...@NoWhere.com (olcott)
Date: Mon, 20 Sep 2021 22:07:02 -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: <87r1di3auk.fsf@bsb.me.uk>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <s9adnRf0JevL0dT8nZ2dnUU7-SPNnZ2d@giganews.com>
Lines: 42
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-Akf7fTcjBQDh45/tyc9NhPFXJcdeV5udwvKr+8WI4jIYnL2fe83LodV1sakPC6FyTf7kjyEstkfng0S!cYDcPWKTnSBmCwEzOFAE0p4ozJ//IB4H0VX3s79sujer3eKhH5oCybttZ2dLfShohbaDnyDLPD4d!1Eo=
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: 3774
View all headers
On 9/20/2021 9:45 PM, Ben Bacarisse wrote:
olcott <NoOne@NoWhere.com> writes:

It doesn't matter what this difference is called, it can even be
called "late for dinner". That this difference exists and causes the
behavior to vary is what needs to be known.

Either H.q0 <H^><H^> and H^.qx <H^><H^> both transition to their
respective rejecting states, or H.q0 <H^><H^> transitions to H.qy and
H^.qx <H^><H^> does not halt.  This difference in behaviour is of no
help to you.

Feel free to quote me.  I won't deny having said this next week.  If I
find I'm wrong about it, I'll say so.  That's what an honest person
does.  Whether anything /you/ say can be trusted will depend on how you
respond to other recent posts.


The same initial input to a specific partial halt decider instance H must always consistently derive the same final output is sustained.

That an exact copy of this partial halt decider instance H1 must alway derive the same results as the original on the same input as the orginal seems to be refuted.

The only exception to the rule may be when the input invokes one of these instances and not the other one.

Ĥ applied to ⟨Ĥ⟩ is applied to its own TM description.
H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ is NOT applied to its own TM description.
This makes the two computations distinctly different.

It may be the case that this is the only exception where identical machines on the same input do not derive identical results.



--
Copyright 2021 Pete Olcott

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


Subject: Re: Why do theory of computation problems require pure functions? [ computation ? ]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic, sci.math
Date: Tue, 21 Sep 2021 15:16 UTC
References: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
X-Received: by 2002:a37:a13:: with SMTP id 19mr1733218qkk.497.1632237378541;
Tue, 21 Sep 2021 08:16:18 -0700 (PDT)
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!news-out.google.com!nntp.google.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Tue, 21 Sep 2021 10:16:13 -0500
Subject: Re: Why do theory of computation problems require pure functions? [
computation ? ]
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <a7WdnftR4JAUzNj8nZ2dnUU7-d_NnZ2d@giganews.com>
<0LKdnQW0_vXAz9v8nZ2dnUU7-RHNnZ2d@giganews.com> <si5o18$ca0$1@dont-email.me>
<b8qdnUQWUNeC-Nv8nZ2dnUU7-cvNnZ2d@giganews.com> <si5p69$qpa$1@dont-email.me>
<i6WdnR3uOcyR9Nv8nZ2dnUU7-TGdnZ2d@giganews.com> <si5qpm$srv$1@dont-email.me>
<b885b582-6153-4184-8dad-aed5dfc83cecn@googlegroups.com>
<87bl4o9rfk.fsf@bsb.me.uk>
<9f3d89f7-6040-4d9f-96e8-4fb18bf6985fn@googlegroups.com>
<877dfc891e.fsf@bsb.me.uk>
<95d4a88f-8fbe-4151-a6bf-c83103d77f1bn@googlegroups.com>
<GdSdnbDQ5umIf9r8nZ2dnUU7-UednZ2d@giganews.com> <875yuv7ei8.fsf@bsb.me.uk>
<i96dnQP238RsBdX8nZ2dnUU7-XPNnZ2d@giganews.com> <87fsty6gxi.fsf@bsb.me.uk>
<VtmdnSy6oZ3Jh9T8nZ2dnUU7-XvNnZ2d@giganews.com> <877dfa6bm8.fsf@bsb.me.uk>
<me2dnZOPq6pzvtT8nZ2dnUU7-Q3NnZ2d@giganews.com>
<Acb2J.135913$o45.5370@fx46.iad>
<mOidnQHsVe4z39T8nZ2dnUU7-VfNnZ2d@giganews.com>
<Lcc2J.32916$GD7.26784@fx23.iad>
<xsednYAjH-48xNT8nZ2dnUU7-U3NnZ2d@giganews.com>
<Bod2J.35998$nR3.3757@fx38.iad>
From: NoO...@NoWhere.com (olcott)
Date: Tue, 21 Sep 2021 10:16:12 -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: <Bod2J.35998$nR3.3757@fx38.iad>
Message-ID: <-YmdnTDXGqGgatT8nZ2dnUU7-U_NnZ2d@giganews.com>
Lines: 253
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-SWeYC3TsFYCaYPBk2Dg3pNYTMtYsDjPqGvHJFxDRvo4cMH352fPyHGDcURWnJalG1IoCp1c0aWp+dMa!HwUI/DN78kPG5rC7WKEXdqDl/3/9eDD+QnyUIoaNxI0WDD/0Lt+UuTFLOlJtnm86oYoolHIZlN8=
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: 12723
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
View all headers
On 9/20/2021 11:42 PM, Richard Damon wrote:
On 9/21/21 12:03 AM, olcott wrote:
On 9/20/2021 10:21 PM, Richard Damon wrote:
On 9/20/21 10:25 PM, olcott wrote:
On 9/20/2021 9:12 PM, Richard Damon wrote:
On 9/20/21 8:14 PM, olcott wrote:
On 9/20/2021 7:00 PM, Ben Bacarisse wrote:
olcott <NoOne@NoWhere.com> writes:

On 9/20/2021 5:06 PM, Ben Bacarisse wrote:
olcott <NoOne@NoWhere.com> writes:

On 9/20/2021 5:00 AM, Ben Bacarisse wrote:
olcott <NoOne@NoWhere.com> writes:

The two machines are already fully operational.
H1 is merely a copy of H.
It's deceptive to call your secret C functions "machines".  It
hints at
the formality a clarity of Turing machines, but a TM that is a
copy of
another will have exactly the same transfer function (i.e. it
will
never
compute a different result).

Unless one of them has a pathological self-reference relationship
with
its input and the other one does not.
No.  I stated a fact (about TMs) that has no exceptions.  Your
secret C
code is another matter, of course.  It's just the deception of
calling
your code a "machine" that I was objecting to.  It gives your
hidden
code an air of formality that it lacks.

This is easily proven in a way that you are incapable of
understanding.

You can't even write English.  Saying "This is easily proven"
following
a quote from me that you are wrong, means you can easily prove what I
said in the quote -- that you are wrong.  That is indeed the case,
but
it is unlikely to be what you meant to say.

Your junk functions are not "machines".  The terms suggests an
undeserved formality.


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

The actual correct x86 emulation of the input to H1(P,P) is different
than the actual correct x86 emulation of the input to H(P,P).

Which means that your emulator is broken, or H isn't a Computation.

PERIOD.


That would mean that "a computation" cannot possibly determine that it
has been invoked in infinitely recursive simulation, whereas a C
function with a a pair of static local variables can.


Right, it can't

Yep, a C code fragment can easily be a non-computation.

This means that a C function can do something that a TM cannot do thus
making it strictly more powerful than a TM. Since this seems implausible
I estimate that you are simply wrong.

Nope.

The Rule is that there is no COMPUTATION that the C function can do that
a Turing Machine can not do. This is the definition of Turing
Competeness and the Turing Equivalence rule.


Yes a C function can determine that it has been called in infinitely
nested simulation only because it is able to maintain static local data
that is not erased between nested simulations.

If a TM cannot maintain static data between nested simulations then a TM
cannot detect when it is within infinitely nested simulations. This
makes the C function strictly more powerful than the TM.

Maybe, but it doesn't mean it can COMPUTE something that a Turing
Machine can, which is the only thing that Computation Theory is
concerned with.

If it isn't a pure mapping of an input to an output, Computation Theory
doesn't care about it.


Also, any 'complete' program (or complete fragment) that has a well
defined input, can be expressed as a Computation, and thus a Turing
Machine could do the equivalent of it. The key here is COMPLETE. You
function isn't 'Complete' as exection goes outside of it and then comes
back in.

Exactly the same way that the simulation of the

machine description of a UTM H that simulates
the machine description P the simulates

machine description of a UTM H that simulates
the machine description P the simulates

machine description of a UTM H that simulates
the machine description P the simulates ...

Olcott H can detect when Olcott P is doing this only because Olcott H
has static local data the survives nested simulations.

If a TM cannot have such static local data then Olcott H is strictly
more powerful than Linz H.



Right, if H IS just a UTM, then H^ is non-halting, but then H doesn't
give an answer to the question H(H^,H^), so it can't answer the question.


Although Olcott H can watch the nested simulation of itself because it has static local data Linz Ĥ could not do this if it is not allowed to have the equivalent of static local data. This would make Olcott H strictly more powerful that Linz Ĥ, when Linz Ĥ is arbitrarily forbidden from having its own static local data.

Once H has the code to abort the simulation loop, and is also still a

We can get here because the Linz Ĥ cannot even get to the point where the abort criteria is matched because it is forced to erase the execution data that would show this.

Computation, then H^ will no longer be stuck in an infinite recursion as
the H inside it will ALSO do that same abort to keep it out of the loop,
and H when coming up with its answer needs to take that into account to
give the right answer.


This never happens. Ĥ must see at least two iterations and without static local data it can at most only see one.

The fact that you can write a program that can detect this sort of
recusion doesn't matter to Computation Theory, it is only concerned
about actual Computations,

It does not make sense that arbitrary rules would allow a C function to be strictly more powerful than a TM so you must be wrong.

and a proper Halt Decider on Computation MUST
be a Computation, as the behavior of a Computaton only depends on the
Machine/ALgorithm and the Input Data, so ANY decider that changes its
answer based on something outside that CAN'T be right, by definition, it
give two different answers for a question that always has the same
answer, so it MUST be wrong at time.


In the case of Olcott H, H merely provides no answer at all until (1) It has seen a behavior pattern that proves that its input matches a never halting behavior pattern (2) Its input halts on its own.

The key here is that if H isn't a Computation, then the 'machine' H^
isn't either, so Computation Theory doesn't care about what it does.


So a halt decider can be made yet it breaks arbitrary rules so no one cares that a halt decider can be made.

The Halting Problem of Computation Theory is STRICTLY about actual
Computations.

If your H ACTUALLY is a correct decider for ALL Turing Machines, then by
definition it needs to be actually a Computation for ANY Turing Machine
given to it, and thus, it can be shown that there does actually exist a
Turing Machine version of it that can take any Turing Machine as an
input. Since this Turing Machine version IS actually a Computation, we
can use the Linz ^ trick on it showing that it gets this case wrong.

It doesn't make sense that a C function can be strictly more powerful that a TM in that it can detect when itself is stuck in finitely nested simulation and a TM cannot do this because it is not allowed to use static local memory therefore you are probable wrong.

The function return values are identical for identical arguments (no variation with local static variables, non-local variables, mutable reference arguments or input streams). https://en.wikipedia.org/wiki/Pure_function

The return values are identical for identical arguments, without static data there is no return value at all.


The only way we can't do this is if your H isn't a computation for some
P(I) so that there isn't a Turing Machine equivalent for it, but then
there are some conditions under which H calls P(I) both Halting and
Non-Halting, so there are some conditions where it gives the wrong
answer, so it isn't the Universal Halt Decider that COmputation Theory
is Looking for.


In those cases where H(P,P) gives and answer that is inconsistent with the behavior of P(P) H1(P,P) gives an answer that is consistent with the behavior of P(P).

We cannot correctly call this a wrong answer because it is a verifiable fact that the input to H(P,P) never halts and H correctly reports this.

The inconsistency is not because H(P,P) is wrong, it is because when H(P,P) aborts the infinitely recursive simulation at any point besides the first infinitely recursive invocation the sequence ceases to be infinitely recursive and then the earlier parts of this infinitely recursive simulation chain come to a halt.

We can know for sure that the whole chain is infinitely recursive when none of the invocations is ever terminated then the chain never halts.

Again, note that if Olcott-H is NOT a strict computation when given an
actual Turing Machine/Input (or equivalent), then BY DEFINTION it must
be wrong some of the time, as to be a non-computation says that there IS
some condition where for an actual computation is predicts both Halting
and Non-Halting for the exact same computation, and thus one of the
answers MUST be wrong.


Self-contradictory inputs derive inconsistent results. The simplest thing to do is simply detect and reject such inputs.

u32 PSR_Olcott_2004(u32 P)
{
   return H1(P,P) != H(P,P);
}

"This sentence is not true" is rejected as a semantically ill-formed truth bearer on the basis that it is self-contradictory.

"This sentence cannot be proven." is rejected as a semantically ill-formed truth bearer on the basis that it is self-contradictory.

Click here to read the complete article
1
rocksolid light 0.7.2
clearneti2ptor